update to released iroh version

Bumps [regex](https://github.com/rust-lang/regex) from 1.6.0 to 1.7.0.
- [Release notes](https://github.com/rust-lang/regex/releases)
- [Changelog](https://github.com/rust-lang/regex/blob/master/CHANGELOG.md)
- [Commits](https://github.com/rust-lang/regex/compare/1.6.0...1.7.0)

---
updated-dependencies:
- dependency-name: regex
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/ci.yml

@@ -40,6 +40,11 @@ jobs:
             toolchain: stable
             components: clippy
             override: true
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v1
+        with:
+          version: '3.20.1'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Cache rust cargo artifacts
         uses: swatinem/rust-cache@v1
       - uses: actions-rs/clippy-check@v1
@@ -55,6 +60,11 @@ jobs:
     steps:
       - name: Checkout sources
         uses: actions/checkout@v2
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v1
+        with:
+          version: '3.20.1'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Install rust stable toolchain
         uses: actions-rs/toolchain@v1
         with:
@@ -77,24 +87,28 @@ jobs:
         include:
           # Currently used Rust version, same as in `rust-toolchain` file.
           - os: ubuntu-latest
-            rust: 1.61.0
+            rust: 1.63.0
             python: 3.9
           - os: windows-latest
-            rust: 1.61.0
+            rust: 1.63.0
             python: false # Python bindings compilation on Windows is not supported.
 
-          # Minimum Supported Rust Version = 1.57.0
+          # Minimum Supported Rust Version = 1.63.0
           #
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
           # built.
           - os: ubuntu-latest
-            rust: 1.57.0
+            rust: 1.63.0
             python: 3.7
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@master
-
+    - name: Install Protoc
+      uses: arduino/setup-protoc@v1
+      with:
+        version: '3.20.1'
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
     - name: Install ${{ matrix.rust }}
       uses: actions-rs/toolchain@v1
       with:

.github/workflows/jsonrpc.yml

@@ -26,6 +26,11 @@ jobs:
           override: true
       - name: Add Rust cache
         uses: Swatinem/rust-cache@v1.3.0
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v1
+        with:
+          version: '3.20.1'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: npm install
         run: |
           cd deltachat-jsonrpc/typescript

.github/workflows/node-package.yml

@@ -27,7 +27,11 @@ jobs:
           cargo -vV
           npm --version
           node --version
-
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v1
+        with:
+          version: '3.20.1'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Cache node modules
         uses: actions/cache@v2
         with:

.github/workflows/node-tests.yml

@@ -27,7 +27,11 @@ jobs:
           cargo -vV
           npm --version
           node --version
-
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v1
+        with:
+          version: '3.20.1'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Cache node modules
         uses: actions/cache@v2
         with:

CHANGELOG.md

@@ -3,10 +3,34 @@
 ## Unreleased
 
 ### Changes
+- Refactor: Remove the remaining AsRef<str> #3669
+- Small speedup #3780
+
+### API-Changes
+- Add Python API to send reactions #3762
+- jsonrpc: add message errors to MessageObject #3788
+
+### Fixes
+- Make sure malformed messsages will never block receiving further messages anymore #3771
+- strip leading/trailing whitespace from "Chat-Group-Name{,-Changed}:" headers content #3650
+- Assume all Thunderbird users prefer encryption #3774
+- refactor peerstate handling to ensure no duplicate peerstates #3776
+
+
+## 1.102.0
+
+### Changes
+
+- If an email has multiple From addresses, handle this as if there was
+  no From address, to prevent from forgery attacks. Also, improve
+  handling of emails with invalid From addresses in general #3667
 
 ### API-Changes
 
 ### Fixes
+- fix detection of "All mail", "Trash", "Junk" etc folders. #3760
+- fetch messages sequentially to fix reactions on partially downloaded messages #3688
+- Fix a bug where one malformed message blocked receiving any further messages #3769
 
 
 ## 1.101.0

Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "deltachat"
-version = "1.101.0"
+version = "1.102.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.57"
+rust-version = "1.63"
 
 [profile.dev]
 debug = 0
@@ -57,7 +57,7 @@ quick-xml = "0.23"
 r2d2 = "0.8"
 r2d2_sqlite = "0.20"
 rand = "0.8"
-regex = "1.6"
+regex = "1.7"
 rusqlite = { version = "0.27", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 rustyline = { version = "10", optional = true }
@@ -74,15 +74,20 @@ toml = "0.5"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }
 fast-socks5 = "0.8"
-humansize = "1"
+humansize = "2"
 qrcodegen = "1.7.0"
 tagger = "4.3.3"
 textwrap = "0.16.0"
 async-channel = "1.6.1"
 futures-lite = "1.12.0"
 tokio-stream = { version = "0.1.11", features = ["fs"] }
-reqwest = { version = "0.11.12", features = ["json"] }
+reqwest = { version = "0.11.13", features = ["json"] }
 async_zip = { version = "0.0.9", default-features = false, features = ["deflate"] }
+iroh-share = { version = "0.1.3" }
+iroh-resolver = { version = "0.1.3", default-features = false }
+tempfile = "3"
+multibase = "0.9"
+port_check = "0.1.5"
 
 [dev-dependencies]
 ansi_term = "0.12.0"

README.md

@@ -120,6 +120,15 @@ $ cargo test -- --ignored
 - `vendored`: When using Openssl for TLS, this bundles a vendored version.
 - `nightly`: Enable nightly only performance and security related features.
 
+## Update Provider Data
+
+To add the updates from the
+[provider-db](https://github.com/deltachat/provider-db) to the core, run:
+
+```
+./src/provider/update.py ../provider-db/_providers/ > src/provider/data.rs
+```
+
 ## Language bindings and frontend projects
 
 Language bindings are available for:

benches/receive_emails.rs

@@ -38,11 +38,64 @@ Hello {i}",
     context
 }
 
+/// Receive 100 emails that remove charlie@example.com and add
+/// him back
+async fn recv_groupmembership_emails(context: Context) -> Context {
+    for i in 0..50 {
+        let imf_raw = format!(
+            "Subject: Benchmark
+Message-ID: Gr.OssSYnOFkhR.{i}@testrun.org
+Date: Sat, 07 Dec 2019 19:00:27 +0000
+To: alice@example.com, b@example.com, c@example.com, d@example.com, e@example.com, f@example.com
+From: sender@testrun.org
+Chat-Version: 1.0
+Chat-Disposition-Notification-To: sender@testrun.org
+Chat-User-Avatar: 0
+Chat-Group-Member-Added: charlie@example.com
+In-Reply-To: Gr.OssSYnOFkhR.{i_dec}@testrun.org
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+
+Hello {i}",
+            i = i,
+            i_dec = i - 1,
+        );
+        receive_imf(&context, black_box(imf_raw.as_bytes()), false)
+            .await
+            .unwrap();
+
+        let imf_raw = format!(
+            "Subject: Benchmark
+Message-ID: Gr.OssSYnOFkhR.{i}@testrun.org
+Date: Sat, 07 Dec 2019 19:00:27 +0000
+To: alice@example.com, b@example.com, c@example.com, d@example.com, e@example.com, f@example.com
+From: sender@testrun.org
+Chat-Version: 1.0
+Chat-Disposition-Notification-To: sender@testrun.org
+Chat-User-Avatar: 0
+Chat-Group-Member-Removed: charlie@example.com
+In-Reply-To: Gr.OssSYnOFkhR.{i_dec}@testrun.org
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+
+Hello {i}",
+            i = i,
+            i_dec = i - 1,
+        );
+        receive_imf(&context, black_box(imf_raw.as_bytes()), false)
+            .await
+            .unwrap();
+    }
+    context
+}
+
 async fn create_context() -> Context {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
     let id = 100;
-    let context = Context::new(&dbfile, id, Events::new(), StockStrings::new())
+    let context = Context::new(dbfile.as_path(), id, Events::new(), StockStrings::new())
         .await
         .unwrap();
 
@@ -52,7 +105,7 @@ async fn create_context() -> Context {
 
     if backup.exists() {
         println!("Importing backup");
-        imex(&context, ImexMode::ImportBackup, &backup, None)
+        imex(&context, ImexMode::ImportBackup, backup.as_path(), None)
             .await
             .unwrap();
     }
@@ -83,6 +136,20 @@ fn criterion_benchmark(c: &mut Criterion) {
             }
         });
     });
+    group.bench_function(
+        "Receive 100 Chat-Group-Member-{Added|Removed} messages",
+        |b| {
+            let rt = tokio::runtime::Runtime::new().unwrap();
+            let context = rt.block_on(create_context());
+
+            b.to_async(&rt).iter(|| {
+                let ctx = context.clone();
+                async move {
+                    recv_groupmembership_emails(black_box(ctx)).await;
+                }
+            });
+        },
+    );
     group.finish();
 }
 

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.101.0"
+version = "1.102.0"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
@@ -26,6 +26,8 @@ anyhow = "1"
 thiserror = "1"
 rand = "0.7"
 once_cell = "1.16.0"
+iroh-share = { version = "0.1.3" }
+multibase = "0.9"
 
 [features]
 default = ["vendored"]

deltachat-ffi/deltachat.h

@@ -24,6 +24,7 @@ typedef struct _dc_provider  dc_provider_t;
 typedef struct _dc_event     dc_event_t;
 typedef struct _dc_event_emitter dc_event_emitter_t;
 typedef struct _dc_jsonrpc_instance dc_jsonrpc_instance_t;
+typedef struct _dc_backup_sender dc_backup_sender_t;
 
 // Alias for backwards compatibility, use dc_event_emitter_t instead.
 typedef struct _dc_event_emitter dc_accounts_event_emitter_t;
@@ -2291,6 +2292,7 @@ void            dc_stop_ongoing_process      (dc_context_t* context);
 #define         DC_QR_FPR_MISMATCH           220 // id=contact
 #define         DC_QR_FPR_WITHOUT_ADDR       230 // test1=formatted fingerprint
 #define         DC_QR_ACCOUNT                250 // text1=domain
+#define         DC_QR_BACKUP                 251
 #define         DC_QR_WEBRTC_INSTANCE        260 // text1=domain, text2=instance pattern
 #define         DC_QR_ADDR                   320 // id=contact
 #define         DC_QR_TEXT                   330 // text1=text
@@ -2336,6 +2338,10 @@ void            dc_stop_ongoing_process      (dc_context_t* context);
  *   ask the user if they want to create an account on the given domain,
  *   if so, call dc_set_config_from_qr() and then dc_configure().
  *
+ * - DC_QR_BACKUP:
+ *   ask the user if they want to set up a new device.
+ *   If so, pass the qr-code to dc_receive_backup().
+ *
  * - DC_QR_WEBRTC_INSTANCE with dc_lot_t::text1=domain:
  *   ask the user if they want to use the given service for video chats;
  *   if so, call dc_set_config_from_qr().
@@ -2626,6 +2632,85 @@ char* dc_get_last_error (dc_context_t* context);
 void dc_str_unref (char* str);
 
 
+/**
+ * @class dc_backup_sender_t
+ *
+ * Set up another device.
+ */
+
+/**
+ * Create an object for sending a backup to another device.
+ * The backup is sent through an peer-to-peer channel which is bootstrapped by a QR-code.
+ * As a backup contains the whole state of the account, including credentials,
+ * this can be used to setup a new device.
+ *
+ * @memberof dc_backup_sender_t
+ * @param context The context.
+ * @param folder Path to create the backup in before it is sent out.
+ *     The path must exist and being accessible at least until the other device has received all data.
+ *     The folder is not cleaned up by the backup send;
+ *     a temporary directory seems to be good place therefore.
+ * @param passphrase Used to at-rest-encrypt the backuped database in `folder` before sending,
+ *     similar to dc_imex().
+ *     The same passphrase must be given to dc_receive_backup() on the other device.
+ *     If NULL or empty string is given, the sent backup is not encrypted at rest.
+ *     The transport of the backup is always encrypted additionally.
+ * @return Opaque object for sending the backup.
+ *     On errors, NULL is returned and dc_get_last_error() returns an error that should be shown to the user.
+ */
+dc_backup_sender_t* dc_send_backup (dc_context_t* context, const char* folder, const char* passphrase);
+
+
+/**
+ * Get QR code text that will offer the backup to other devices.
+ * The QR code contains a ticket that will unambiguously identify the backup.
+ *
+ * The scanning device will pass the scanned content to dc_check_qr() then;
+ * if dc_check_qr() returns DC_QR_BACKUP,
+ * the backup transfer can be started using dc_receive_backup().
+ *
+ * @memberof dc_backup_sender_t
+ * @param context The context.
+ * @param backup_sender The backup sender object as created by dc_send_backup().
+ * @return The text that should go to the QR code,
+ *     On errors, an empty QR code is returned, NULL is never returned.
+ *     The returned string must be released using dc_str_unref() after usage.
+ */
+char* dc_backup_sender_qr (dc_context_t* context, const dc_backup_sender_t* backup_sender);
+
+
+/**
+ * Waits for the sending to finish and frees the backup sender object.
+ *
+ * @memberof dc_backup_sender_t
+ * @param context The context.
+ * @param backup_sender The backup sender object as created by dc_send_backup(),
+ *     If NULL is given, nothing is done.
+ */
+void dc_backup_sender_done (dc_context_t* context, dc_backup_sender_t* backup_sender);
+
+
+/**
+ * Receive a backup offered by a dc_backup_sender_t object on another device.
+ *
+ * This function is typically not called on the device where the dc_backup_sender_t object exist,
+ * but on a device that has scanned the QR code generated by dc_backup_sender_qr().
+ *
+ * While dc_receive_backup() returns immediately, the started job may take a while;
+ * you can stop it using dc_stop_ongoing_process().
+ * During execution of the job #DC_EVENT_IMEX_PROGRESS is sent out several times to indicate state and progress.
+ *
+ * @memberof dc_backup_sender_t
+ * @param context The context.
+ * @param qr The qr code containing all data needed to transfer the backup;
+ *     usually, this is the case if dc_check_qr() returns DC_QR_BACKUP.
+ * @param passphrase Passphrase for the additional at-rest-encryption
+ *     as defined at dc_send_backup() on the other device.
+ *     If no passphrase is used, pass NULL or empty string.
+ */
+void dc_receive_backup (dc_context_t* context, const char* qr, const char* passphrase);
+
+
 /**
  * @class dc_accounts_t
  *

deltachat-ffi/src/lib.rs

@@ -51,6 +51,7 @@ mod lot;
 mod string;
 use self::string::*;
 use deltachat::chatlist::Chatlist;
+use deltachat::qr::Qr;
 
 // as C lacks a good and portable error handling,
 // in general, the C Interface is forgiving wrt to bad parameters.
@@ -1659,7 +1660,7 @@ pub unsafe extern "C" fn dc_set_chat_profile_image(
     let ctx = &*context;
 
     block_on(async move {
-        chat::set_chat_profile_image(ctx, ChatId::new(chat_id), to_string_lossy(image))
+        chat::set_chat_profile_image(ctx, ChatId::new(chat_id), &to_string_lossy(image))
             .await
             .map(|_| 1)
             .unwrap_or_log_default(ctx, "Failed to set profile image")
@@ -2204,6 +2205,97 @@ pub unsafe extern "C" fn dc_imex(
     }
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_send_backup(
+    context: *mut dc_context_t,
+    folder: *const libc::c_char,
+    passphrase: *const libc::c_char,
+) -> *mut dc_backup_sender {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_send_backup()");
+        return ptr::null_mut();
+    }
+
+    let passphrase = to_opt_string_lossy(passphrase);
+    let ctx = &*context;
+
+    if let Some(folder) = to_opt_string_lossy(folder) {
+        block_on(async move {
+            imex::send_backup(ctx, folder.as_ref(), passphrase)
+                .await
+                .map(|transfer| Box::into_raw(Box::new(dc_backup_sender { transfer })))
+                .log_err(ctx, "send_backup failed")
+                .unwrap_or(ptr::null_mut())
+        })
+    } else {
+        eprintln!("dc_imex called without a valid directory");
+        ptr::null_mut()
+    }
+}
+
+pub struct dc_backup_sender {
+    transfer: iroh_share::SenderTransfer,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_backup_sender_qr(
+    ctx: *mut dc_context_t,
+    bs: *const dc_backup_sender,
+) -> *mut libc::c_char {
+    if ctx.is_null() || bs.is_null() {
+        eprintln!("ignoring careless call to dc_backup_sender_qr");
+        return ptr::null_mut();
+    }
+    let ctx = &*ctx;
+    let bs = &*bs;
+    let ticket = bs.transfer.ticket();
+
+    qr_code_generator::generate_backup_qr_code(ticket)
+        .map(|s| s.strdup())
+        .log_err(ctx, "generate_backup_qr_code failed")
+        .unwrap_or(ptr::null_mut())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_backup_sender_done(ctx: *mut dc_context_t, bs: *mut dc_backup_sender) {
+    if ctx.is_null() || bs.is_null() {
+        eprintln!("ignoring careless call to dc_backup_sender_wait");
+        return;
+    }
+    let ctx = &*ctx;
+    let bs = Box::from_raw(bs);
+
+    block_on(async move {
+        if let Err(e) = bs.transfer.done().await {
+            error!(ctx, "sending backup failed: {:?}", e);
+        }
+    });
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_receive_backup(
+    ctx: *mut dc_context_t,
+    qr: *const libc::c_char,
+    passphrase: *const libc::c_char,
+) {
+    if ctx.is_null() {
+        eprintln!("ignoring careless call to dc_receive_backup");
+        return;
+    }
+    let ctx = &*ctx;
+    let ticket = match block_on(qr::check_qr(ctx, &to_string_lossy(qr))) {
+        Ok(Qr::Backup { ticket }) => ticket.as_bytes(),
+        _ => vec![],
+    };
+    let passphrase = to_opt_string_lossy(passphrase);
+
+    spawn(async move {
+        imex::receive_backup(ctx, ticket, passphrase)
+            .await
+            .log_err(ctx, "IMEX failed")
+    });
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_imex_has_backup(
     context: *mut dc_context_t,

deltachat-ffi/src/lot.rs

@@ -50,6 +50,7 @@ impl Lot {
                 Qr::FprMismatch { .. } => None,
                 Qr::FprWithoutAddr { fingerprint, .. } => Some(fingerprint),
                 Qr::Account { domain } => Some(domain),
+                Qr::Backup { .. } => None,
                 Qr::WebrtcInstance { domain, .. } => Some(domain),
                 Qr::Addr { draft, .. } => draft.as_deref(),
                 Qr::Url { url } => Some(url),
@@ -101,6 +102,7 @@ impl Lot {
                 Qr::FprMismatch { .. } => LotState::QrFprMismatch,
                 Qr::FprWithoutAddr { .. } => LotState::QrFprWithoutAddr,
                 Qr::Account { .. } => LotState::QrAccount,
+                Qr::Backup { .. } => LotState::QrBackup,
                 Qr::WebrtcInstance { .. } => LotState::QrWebrtcInstance,
                 Qr::Addr { .. } => LotState::QrAddr,
                 Qr::Url { .. } => LotState::QrUrl,
@@ -125,6 +127,7 @@ impl Lot {
                 Qr::FprMismatch { contact_id } => contact_id.unwrap_or_default().to_u32(),
                 Qr::FprWithoutAddr { .. } => Default::default(),
                 Qr::Account { .. } => Default::default(),
+                Qr::Backup { .. } => Default::default(),
                 Qr::WebrtcInstance { .. } => Default::default(),
                 Qr::Addr { contact_id, .. } => contact_id.to_u32(),
                 Qr::Url { .. } => Default::default(),
@@ -173,6 +176,9 @@ pub enum LotState {
     /// text1=domain
     QrAccount = 250,
 
+    /// TODO
+    QrBackup = 251,
+
     /// text1=domain, text2=instance pattern
     QrWebrtcInstance = 260,
 

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.101.0"
+version = "1.102.0"
 description = "DeltaChat JSON-RPC API"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"
@@ -23,7 +23,7 @@ async-channel = { version = "1.6.1" }
 futures = { version = "0.3.25" }
 serde_json = "1.0.87"
 yerpc = { version = "^0.3.1", features = ["anyhow_expose"] }
-typescript-type-def = { version = "0.5.3", features = ["json_value"] }
+typescript-type-def = { version = "0.5.5", features = ["json_value"] }
 tokio = { version = "1.21.2" }
 sanitize-filename = "0.4"
 walkdir = "2.3.2"

deltachat-jsonrpc/src/api/mod.rs

@@ -733,7 +733,7 @@ impl CommandApi {
         image_path: Option<String>,
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
-        chat::set_chat_profile_image(&ctx, ChatId::new(chat_id), image_path.unwrap_or_default())
+        chat::set_chat_profile_image(&ctx, ChatId::new(chat_id), &image_path.unwrap_or_default())
             .await
     }
 
@@ -1146,12 +1146,12 @@ impl CommandApi {
         Ok(contacts)
     }
 
-    async fn delete_contact(&self, account_id: u32, contact_id: u32) -> Result<bool> {
+    async fn delete_contact(&self, account_id: u32, contact_id: u32) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
         let contact_id = ContactId::new(contact_id);
 
         Contact::delete(&ctx, contact_id).await?;
-        Ok(true)
+        Ok(())
     }
 
     async fn change_contact_name(

deltachat-jsonrpc/src/api/types/message.rs

@@ -34,6 +34,9 @@ pub struct MessageObject {
     view_type: MessageViewtype,
     state: u32,
 
+    /// An error text, if there is one.
+    error: Option<String>,
+
     timestamp: i64,
     sort_timestamp: i64,
     received_timestamp: i64,
@@ -167,6 +170,7 @@ impl MessageObject {
                 .get_state()
                 .to_u32()
                 .ok_or_else(|| anyhow!("state conversion to number failed"))?,
+            error: message.error(),
 
             timestamp: message.get_timestamp(),
             sort_timestamp: message.get_sort_timestamp(),

deltachat-jsonrpc/src/api/types/mod.rs

@@ -20,3 +20,215 @@ fn maybe_empty_string_to_option(string: String) -> Option<String> {
         Some(string)
     }
 }
+#[derive(Serialize, TypeDef)]
+#[serde(rename = "Qr", rename_all = "camelCase")]
+#[serde(tag = "type")]
+pub enum QrObject {
+    AskVerifyContact {
+        contact_id: u32,
+        fingerprint: String,
+        invitenumber: String,
+        authcode: String,
+    },
+    AskVerifyGroup {
+        grpname: String,
+        grpid: String,
+        contact_id: u32,
+        fingerprint: String,
+        invitenumber: String,
+        authcode: String,
+    },
+    FprOk {
+        contact_id: u32,
+    },
+    FprMismatch {
+        contact_id: Option<u32>,
+    },
+    FprWithoutAddr {
+        fingerprint: String,
+    },
+    Account {
+        domain: String,
+    },
+    WebrtcInstance {
+        domain: String,
+        instance_pattern: String,
+    },
+    Addr {
+        contact_id: u32,
+        draft: Option<String>,
+    },
+    Url {
+        url: String,
+    },
+    Text {
+        text: String,
+    },
+    WithdrawVerifyContact {
+        contact_id: u32,
+        fingerprint: String,
+        invitenumber: String,
+        authcode: String,
+    },
+    WithdrawVerifyGroup {
+        grpname: String,
+        grpid: String,
+        contact_id: u32,
+        fingerprint: String,
+        invitenumber: String,
+        authcode: String,
+    },
+    ReviveVerifyContact {
+        contact_id: u32,
+        fingerprint: String,
+        invitenumber: String,
+        authcode: String,
+    },
+    ReviveVerifyGroup {
+        grpname: String,
+        grpid: String,
+        contact_id: u32,
+        fingerprint: String,
+        invitenumber: String,
+        authcode: String,
+    },
+    Login {
+        address: String,
+    },
+}
+
+impl From<Qr> for QrObject {
+    fn from(qr: Qr) -> Self {
+        match qr {
+            Qr::AskVerifyContact {
+                contact_id,
+                fingerprint,
+                invitenumber,
+                authcode,
+            } => {
+                let contact_id = contact_id.to_u32();
+                let fingerprint = fingerprint.to_string();
+                QrObject::AskVerifyContact {
+                    contact_id,
+                    fingerprint,
+                    invitenumber,
+                    authcode,
+                }
+            }
+            Qr::AskVerifyGroup {
+                grpname,
+                grpid,
+                contact_id,
+                fingerprint,
+                invitenumber,
+                authcode,
+            } => {
+                let contact_id = contact_id.to_u32();
+                let fingerprint = fingerprint.to_string();
+                QrObject::AskVerifyGroup {
+                    grpname,
+                    grpid,
+                    contact_id,
+                    fingerprint,
+                    invitenumber,
+                    authcode,
+                }
+            }
+            Qr::FprOk { contact_id } => {
+                let contact_id = contact_id.to_u32();
+                QrObject::FprOk { contact_id }
+            }
+            Qr::FprMismatch { contact_id } => {
+                let contact_id = contact_id.map(|contact_id| contact_id.to_u32());
+                QrObject::FprMismatch { contact_id }
+            }
+            Qr::FprWithoutAddr { fingerprint } => QrObject::FprWithoutAddr { fingerprint },
+            Qr::Account { domain } => QrObject::Account { domain },
+            Qr::WebrtcInstance {
+                domain,
+                instance_pattern,
+            } => QrObject::WebrtcInstance {
+                domain,
+                instance_pattern,
+            },
+            Qr::Addr { contact_id, draft } => {
+                let contact_id = contact_id.to_u32();
+                QrObject::Addr { contact_id, draft }
+            }
+            Qr::Url { url } => QrObject::Url { url },
+            Qr::Text { text } => QrObject::Text { text },
+            Qr::WithdrawVerifyContact {
+                contact_id,
+                fingerprint,
+                invitenumber,
+                authcode,
+            } => {
+                let contact_id = contact_id.to_u32();
+                let fingerprint = fingerprint.to_string();
+                QrObject::WithdrawVerifyContact {
+                    contact_id,
+                    fingerprint,
+                    invitenumber,
+                    authcode,
+                }
+            }
+            Qr::WithdrawVerifyGroup {
+                grpname,
+                grpid,
+                contact_id,
+                fingerprint,
+                invitenumber,
+                authcode,
+            } => {
+                let contact_id = contact_id.to_u32();
+                let fingerprint = fingerprint.to_string();
+                QrObject::WithdrawVerifyGroup {
+                    grpname,
+                    grpid,
+                    contact_id,
+                    fingerprint,
+                    invitenumber,
+                    authcode,
+                }
+            }
+            Qr::ReviveVerifyContact {
+                contact_id,
+                fingerprint,
+                invitenumber,
+                authcode,
+            } => {
+                let contact_id = contact_id.to_u32();
+                let fingerprint = fingerprint.to_string();
+                QrObject::ReviveVerifyContact {
+                    contact_id,
+                    fingerprint,
+                    invitenumber,
+                    authcode,
+                }
+            }
+            Qr::ReviveVerifyGroup {
+                grpname,
+                grpid,
+                contact_id,
+                fingerprint,
+                invitenumber,
+                authcode,
+            } => {
+                let contact_id = contact_id.to_u32();
+                let fingerprint = fingerprint.to_string();
+                QrObject::ReviveVerifyGroup {
+                    grpname,
+                    grpid,
+                    contact_id,
+                    fingerprint,
+                    invitenumber,
+                    authcode,
+                }
+            }
+            Qr::Login { address, .. } => QrObject::Login { address },
+            Qr::Backup { ticket } => QrObject::Backup {
+                ticket: ticket.as_bytes(),
+            },
+        }
+    }
+}

deltachat-jsonrpc/typescript/generated/types.ts

@@ -4,7 +4,8 @@ export type U32=number;
 export type Account=(({"type":"Configured";}&{"id":U32;"displayName":(string|null);"addr":(string|null);"profileImage":(string|null);"color":string;})|({"type":"Unconfigured";}&{"id":U32;}));
 export type U64=number;
 export type ProviderInfo={"beforeLoginHint":string;"overviewPage":string;"status":U32;};
-export type Qr=(({"type":"askVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"askVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"fprOk";}&{"contact_id":U32;})|({"type":"fprMismatch";}&{"contact_id":(U32|null);})|({"type":"fprWithoutAddr";}&{"fingerprint":string;})|({"type":"account";}&{"domain":string;})|({"type":"webrtcInstance";}&{"domain":string;"instance_pattern":string;})|({"type":"addr";}&{"contact_id":U32;"draft":(string|null);})|({"type":"url";}&{"url":string;})|({"type":"text";}&{"text":string;})|({"type":"withdrawVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"withdrawVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"reviveVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"reviveVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"login";}&{"address":string;}));
+export type U8=number;
+export type Qr=(({"type":"askVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"askVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"fprOk";}&{"contact_id":U32;})|({"type":"fprMismatch";}&{"contact_id":(U32|null);})|({"type":"fprWithoutAddr";}&{"fingerprint":string;})|({"type":"account";}&{"domain":string;})|({"type":"webrtcInstance";}&{"domain":string;"instance_pattern":string;})|({"type":"addr";}&{"contact_id":U32;"draft":(string|null);})|({"type":"url";}&{"url":string;})|({"type":"text";}&{"text":string;})|({"type":"withdrawVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"withdrawVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"reviveVerifyContact";}&{"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"reviveVerifyGroup";}&{"grpname":string;"grpid":string;"contact_id":U32;"fingerprint":string;"invitenumber":string;"authcode":string;})|({"type":"login";}&{"address":string;})|({"type":"backup";}&{"ticket":(U8)[];}));
 export type Usize=number;
 export type I64=number;
 export type ChatListEntry=[U32,U32];

deltachat-jsonrpc/typescript/package.json

@@ -48,5 +48,5 @@
   },
   "type": "module",
   "types": "dist/deltachat.d.ts",
-  "version": "1.101.0"
+  "version": "1.102.0"
 }

deltachat-jsonrpc/typescript/src/client.ts

@@ -43,12 +43,14 @@ export class BaseDeltaChat<
       const method = request.method;
       if (method === "event") {
         const event = request.params! as DCWireEvent<Event>;
+	//@ts-ignore
         this.emit(event.event.type, event.contextId, event.event as any);
         this.emit("ALL", event.contextId, event.event as any);
 
         if (this.contextEmitters[event.contextId]) {
           this.contextEmitters[event.contextId].emit(
             event.event.type,
+            //@ts-ignore
             event.event as any
           );
           this.contextEmitters[event.contextId].emit("ALL", event.event);

deltachat-rpc-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.101.0"
+version = "1.102.0"
 description = "DeltaChat JSON-RPC server"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"

draft/webxdc-dev-reference.md

@@ -4,7 +4,7 @@ This document gives a quick overview about the Webxdc specification,
 It is meant for both, developing Webxdc apps
 and developing Webxdc implementations.
 
-The [Webxdc guidebook](https://deltachat.github.io/webxdc_docs/) shows more detailed information
+The [Webxdc guidebook](https://docs.webxdc.org/) shows more detailed information
 when developing Webxdc apps.
 
 

examples/repl/cmdline.rs

@@ -335,6 +335,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                  continue-key-transfer <msg-id> <setup-code>\n\
                  has-backup\n\
                  export-backup\n\
+                 send-backup [<passphrase>]\n\
+                 receive-backup <ticket> [<passphrase>]\n\
                  import-backup <backup-file>\n\
                  export-keys\n\
                  import-keys\n\
@@ -475,7 +477,30 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 Some(arg2.to_string()),
             )
             .await?;
-            println!("Exported to {}.", dir.to_string_lossy());
+            println!("Exported to {}.", dir.display());
+        }
+        "send-backup" => {
+            let tdir = tempfile::TempDir::new()?;
+            let dir = tdir.path();
+            println!("Storing backup in: {} ", dir.display());
+            let transfer = send_backup(&context, dir, Some(arg1.to_string())).await?;
+            let ticket = transfer.ticket();
+            let ticket_bytes = ticket.as_bytes();
+
+            println!(
+                "Ticket: {}",
+                multibase::encode(multibase::Base::Base64, &ticket_bytes)
+            );
+            let qr_code = deltachat::qr_code_generator::generate_backup_qr_code(ticket)?;
+            let file = dir.join("qr.svg");
+            tokio::fs::write(file, qr_code.as_bytes()).await?;
+
+            transfer.done().await?;
+        }
+        "receive-backup" => {
+            ensure!(!arg1.is_empty(), "Argument <ticket> is missing.");
+            let (_, ticket) = multibase::decode(&arg1)?;
+            receive_backup(&context, ticket, Some(arg2.to_string())).await?;
         }
         "import-backup" => {
             ensure!(!arg1.is_empty(), "Argument <backup-file> missing.");

examples/repl/main.rs

@@ -155,13 +155,15 @@ impl Completer for DcHelper {
     }
 }
 
-const IMEX_COMMANDS: [&str; 12] = [
+const IMEX_COMMANDS: [&str; 14] = [
     "initiate-key-transfer",
     "get-setupcodebegin",
     "continue-key-transfer",
     "has-backup",
     "export-backup",
     "import-backup",
+    "send-backup",
+    "receive-backup",
     "export-keys",
     "import-keys",
     "export-setup",

node/test/test.js

@@ -616,7 +616,7 @@ describe('Offline Tests with unconfigured account', function () {
     const id = context.createContact('someuser', 'someuser@site.com')
     const contact = context.getContact(id)
     strictEqual(contact.getId(), id, 'contact id matches')
-    strictEqual(context.deleteContact(id), true, 'delete call succesful')
+    context.deleteContact(id)
     strictEqual(context.getContact(id), null, 'contact is gone')
   })
 

package.json

@@ -60,5 +60,5 @@
     "test:mocha": "mocha -r esm node/test/test.js --growl --reporter=spec --bail --exit"
   },
   "types": "node/dist/index.d.ts",
-  "version": "1.101.0"
+  "version": "1.102.0"
 }

python/src/deltachat/_build.py

@@ -156,6 +156,7 @@ def extract_defines(flags):
                 | DC_KEY_GEN
                 | DC_IMEX
                 | DC_CONNECTIVITY
+                | DC_DOWNLOAD
             )         # End of prefix matching
             _[\w_]+   # Match the suffix, e.g. _RSA2048 in DC_KEY_GEN_RSA2048
         )             # Close the capturing group, this contains

python/src/deltachat/events.py

@@ -192,6 +192,12 @@ class FFIEventTracker:
             return self.account.get_message_by_id(ev.data2)
         return None
 
+    def wait_next_reactions_changed(self):
+        """wait for and return next reactions-changed message"""
+        ev = self.get_matching("DC_EVENT_REACTIONS_CHANGED")
+        assert ev.data1 > 0
+        return self.account.get_message_by_id(ev.data2)
+
     def wait_msg_delivered(self, msg):
         ev = self.get_matching("DC_EVENT_MSG_DELIVERED")
         assert ev.data1 == msg.chat.id
@@ -296,6 +302,10 @@ class EventThread(threading.Thread):
                         "ac_incoming_message",
                         dict(message=msg),
                     )
+        elif name == "DC_EVENT_REACTIONS_CHANGED":
+            assert ffi_event.data1 > 0
+            msg = account.get_message_by_id(ffi_event.data2)
+            yield "ac_reactions_changed", dict(message=msg)
         elif name == "DC_EVENT_MSG_DELIVERED":
             msg = account.get_message_by_id(ffi_event.data2)
             yield "ac_message_delivered", dict(message=msg)

python/src/deltachat/hookspec.py

@@ -49,6 +49,10 @@ class PerAccount:
     def ac_outgoing_message(self, message):
         """Called on each outgoing message (both system and "normal")."""
 
+    @account_hookspec
+    def ac_reactions_changed(self, message):
+        """Called when message reactions changed."""
+
     @account_hookspec
     def ac_message_delivered(self, message):
         """Called when an outgoing message has been delivered to SMTP.

python/src/deltachat/message.py

@@ -9,6 +9,7 @@ from typing import Optional, Union
 from . import const, props
 from .capi import ffi, lib
 from .cutil import as_dc_charpointer, from_dc_charpointer, from_optional_dc_charpointer
+from .reactions import Reactions
 
 
 class Message(object):
@@ -161,6 +162,17 @@ class Message(object):
             )
         )
 
+    def send_reaction(self, reaction: str):
+        """Send a reaction to message and return the resulting Message instance."""
+        msg_id = lib.dc_send_reaction(self.account._dc_context, self.id, as_dc_charpointer(reaction))
+        if msg_id == 0:
+            raise ValueError("reaction could not be send")
+        return Message.from_db(self.account, msg_id)
+
+    def get_reactions(self) -> Reactions:
+        """Get :class:`deltachat.reactions.Reactions` to the message."""
+        return Reactions.from_msg(self)
+
     def is_system_message(self):
         """return True if this message is a system/info message."""
         return bool(lib.dc_msg_is_info(self._dc_msg))
@@ -449,6 +461,17 @@ class Message(object):
         """mark this message as seen."""
         self.account.mark_seen_messages([self.id])
 
+    #
+    # Message download state
+    #
+    @property
+    def download_state(self):
+        assert self.id > 0
+
+        # load message from db to get a fresh/current state
+        dc_msg = ffi.gc(lib.dc_get_msg(self.account._dc_context, self.id), lib.dc_msg_unref)
+        return lib.dc_msg_get_download_state(dc_msg)
+
 
 # some code for handling DC_MSG_* view types
 

python/src/deltachat/reactions.py

@@ -0,0 +1,43 @@
+""" The Reactions object. """
+
+from .capi import ffi, lib
+from .cutil import from_dc_charpointer, iter_array
+
+
+class Reactions(object):
+    """Reactions object.
+
+    You obtain instances of it through :class:`deltachat.message.Message`.
+    """
+
+    def __init__(self, account, dc_reactions):
+        assert isinstance(account._dc_context, ffi.CData)
+        assert isinstance(dc_reactions, ffi.CData)
+        assert dc_reactions != ffi.NULL
+        self.account = account
+        self._dc_reactions = dc_reactions
+
+    def __repr__(self):
+        return "<Reactions dc_reactions={}>".format(self._dc_reactions)
+
+    @classmethod
+    def from_msg(cls, msg):
+        assert msg.id > 0
+        return cls(
+            msg.account,
+            ffi.gc(lib.dc_get_msg_reactions(msg.account._dc_context, msg.id), lib.dc_reactions_unref),
+        )
+
+    def get_contacts(self) -> list:
+        """Get list of contacts reacted to the message.
+
+        :returns: list of :class:`deltachat.contact.Contact` objects for this reaction.
+        """
+        from .contact import Contact
+
+        dc_array = ffi.gc(lib.dc_reactions_get_contacts(self._dc_reactions), lib.dc_array_unref)
+        return list(iter_array(dc_array, lambda x: Contact(self.account, x)))
+
+    def get_by_contact(self, contact) -> str:
+        """Get a string containing space-separated reactions of a single :class:`deltachat.contact.Contact`."""
+        return from_dc_charpointer(lib.dc_reactions_get_by_contact_id(self._dc_reactions, contact.id))

python/tests/test_1_online.py

@@ -405,6 +405,29 @@ def test_forward_own_message(acfactory, lp):
     assert msg_in.is_forwarded()
 
 
+def test_long_group_name(acfactory, lp):
+    """See bug https://github.com/deltachat/deltachat-core-rust/issues/3650 "Space added before long
+    group names after MIME serialization/deserialization".
+
+    When the mailadm bot creates a group with botadmin, the bot creates is as
+    "pytest-supportuser-282@x.testrun.org support group" (for example). But in the botadmin's
+    account object, the group chat is called " pytest-supportuser-282@x.testrun.org support group"
+    (with an additional space character in the beginning).
+    """
+    ac1, ac2 = acfactory.get_online_accounts(2)
+
+    lp.sec("ac1: creating group chat and sending a message")
+    group_name = "pytest-supportuser-282@x.testrun.org support group"
+    group = ac1.create_group_chat(group_name)
+    group.add_contact(ac2)
+    group.send_text("message")
+
+    # wait for other account to receive
+    ev = ac2._evtracker.get_matching("DC_EVENT_INCOMING_MSG")
+    msg_in = ac2.get_message_by_id(ev.data2)
+    assert msg_in.chat.get_name() == group_name
+
+
 def test_send_self_message(acfactory, lp):
     ac1 = acfactory.new_online_configuring_account(mvbox_move=True)
     acfactory.bring_accounts_online()
@@ -901,6 +924,34 @@ def test_dont_show_emails(acfactory, lp):
             ac1.get_config("configured_addr")
         ),
     )
+    ac1.direct_imap.append(
+        "Spam",
+        """
+        From: unknown.address@junk.org, unkwnown.add@junk.org
+        Subject: subj
+        To: {}
+        Message-ID: <spam.message2@junk.org>
+        Content-Type: text/plain; charset=utf-8
+
+        Unknown & malformed message in Spam
+    """.format(
+            ac1.get_config("configured_addr")
+        ),
+    )
+    ac1.direct_imap.append(
+        "Spam",
+        """
+        From: alice@example.org
+        Subject: subj
+        To: {}
+        Message-ID: <spam.message3@junk.org>
+        Content-Type: text/plain; charset=utf-8
+
+        Actually interesting message in Spam
+    """.format(
+            ac1.get_config("configured_addr")
+        ),
+    )
     ac1.direct_imap.append(
         "Junk",
         """
@@ -926,7 +977,9 @@ def test_dont_show_emails(acfactory, lp):
     ac1._evtracker.wait_idle_inbox_ready()
 
     assert msg.text == "subj – message in Sent"
-    assert len(msg.chat.get_messages()) == 1
+    chat_msgs = msg.chat.get_messages()
+    assert len(chat_msgs) == 2
+    assert any(msg.text == "subj – Actually interesting message in Spam" for msg in chat_msgs)
 
     assert not any("unknown.address" in c.get_name() for c in ac1.get_chats())
     ac1.direct_imap.select_folder("Spam")
@@ -942,7 +995,7 @@ def test_dont_show_emails(acfactory, lp):
     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
+    assert len(msg.chat.get_messages()) == 3
 
 
 def test_no_old_msg_is_fresh(acfactory, lp):
@@ -1237,6 +1290,66 @@ def test_send_and_receive_image(acfactory, lp, data):
     assert m == msg_in
 
 
+def test_reaction_to_partially_fetched_msg(acfactory, lp, tmpdir):
+    """See https://github.com/deltachat/deltachat-core-rust/issues/3688 "Partially downloaded
+    messages are received out of order".
+
+    If the Inbox contains X small messages followed by Y large messages followed by Z small
+    messages, Delta Chat first downloaded a batch of X+Z messages, and then a batch of Y messages.
+
+    This bug was discovered by @Simon-Laux while testing reactions PR #3644 and can be reproduced
+    with online test as follows:
+    - Bob enables download limit and goes offline.
+    - Alice sends a large message to Bob and reacts to this message with a thumbs-up.
+    - Bob goes online
+    - Bob first processes a reaction message and throws it away because there is no corresponding
+      message, then processes a partially downloaded message.
+    - As a result, Bob does not see a reaction
+    """
+    download_limit = 32768
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1_addr = ac1.get_config("addr")
+    chat = ac1.create_chat(ac2)
+    ac2.set_config("download_limit", str(download_limit))
+    ac2.stop_io()
+
+    reactions_queue = queue.Queue()
+
+    class InPlugin:
+        @account_hookimpl
+        def ac_reactions_changed(self, message):
+            reactions_queue.put(message)
+
+    ac2.add_account_plugin(InPlugin())
+
+    lp.sec("sending small+large messages from ac1 to ac2")
+    msgs = []
+    msgs.append(chat.send_text("hi"))
+    path = tmpdir.join("large")
+    with open(path, "wb") as fout:
+        fout.write(os.urandom(download_limit + 1))
+    msgs.append(chat.send_file(path.strpath))
+
+    lp.sec("sending a reaction to the large message from ac1 to ac2")
+    react_str = "\N{THUMBS UP SIGN}"
+    msgs.append(msgs[-1].send_reaction(react_str))
+
+    for m in msgs:
+        ac1._evtracker.wait_msg_delivered(m)
+    ac2.start_io()
+
+    lp.sec("wait for ac2 to receive a reaction")
+    msg2 = ac2._evtracker.wait_next_reactions_changed()
+    assert msg2.get_sender_contact().addr == ac1_addr
+    assert msg2.download_state == const.DC_DOWNLOAD_AVAILABLE
+    assert reactions_queue.get() == msg2
+    reactions = msg2.get_reactions()
+    contacts = reactions.get_contacts()
+    assert len(contacts) == 1
+    assert contacts[0].addr == ac1_addr
+    assert reactions.get_by_contact(contacts[0]) == react_str
+
+
 def test_import_export_online_all(acfactory, tmpdir, data, lp):
     (ac1,) = acfactory.get_online_accounts(1)
 

rust-toolchain

@@ -1 +1 @@
-1.61.0
+1.63.0

scripts/coredeps/install-rust.sh

@@ -7,7 +7,7 @@ set -euo pipefail
 #
 # Avoid using rustup here as it depends on reading /proc/self/exe and
 # has problems running under QEMU.
-RUST_VERSION=1.61.0
+RUST_VERSION=1.63.0
 
 ARCH="$(uname -m)"
 test -f "/lib/libc.musl-$ARCH.so.1" && LIBC=musl || LIBC=gnu

src/authres.rs

@@ -34,10 +34,9 @@ pub(crate) async fn handle_authres(
     let from_domain = match EmailAddress::new(from) {
         Ok(email) => email.domain,
         Err(e) => {
-            warn!(context, "invalid email {:#}", e);
             // This email is invalid, but don't return an error, we still want to
             // add a stub to the database so that it's not downloaded again
-            return Ok(DkimResults::default());
+            return Err(anyhow::format_err!("invalid email {}: {:#}", from, e));
         }
     };
 
@@ -574,7 +573,7 @@ Authentication-Results: box.hispanilandia.net; spf=pass smtp.mailfrom=adbenitez@
                 file.read_to_end(&mut bytes).await.unwrap();
 
                 let mail = mailparse::parse_mail(&bytes)?;
-                let from = &mimeparser::get_from(&mail.headers)[0].addr;
+                let from = &mimeparser::get_from(&mail.headers).unwrap().addr;
 
                 let res = handle_authres(&t, &mail, from, time()).await?;
                 assert!(res.allow_keychange);
@@ -586,7 +585,7 @@ Authentication-Results: box.hispanilandia.net; spf=pass smtp.mailfrom=adbenitez@
                 file.read_to_end(&mut bytes).await.unwrap();
 
                 let mail = mailparse::parse_mail(&bytes)?;
-                let from = &mimeparser::get_from(&mail.headers)[0].addr;
+                let from = &mimeparser::get_from(&mail.headers).unwrap().addr;
 
                 let res = handle_authres(&t, &mail, from, time()).await?;
                 if !res.allow_keychange {
@@ -637,9 +636,10 @@ Authentication-Results: box.hispanilandia.net; spf=pass smtp.mailfrom=adbenitez@
         // Even if the format is wrong and parsing fails, handle_authres() shouldn't
         // return an Err because this would prevent the message from being added
         // to the database and downloaded again and again
-        let bytes = b"Authentication-Results: dkim=";
+        let bytes = b"From: invalid@from.com
+Authentication-Results: dkim=";
         let mail = mailparse::parse_mail(bytes).unwrap();
-        handle_authres(&t, &mail, "invalidfrom.com", time())
+        handle_authres(&t, &mail, "invalid@rom.com", time())
             .await
             .unwrap();
     }
@@ -681,7 +681,7 @@ Authentication-Results: box.hispanilandia.net; spf=pass smtp.mailfrom=adbenitez@
             .await;
 
         sent.payload
-            .insert_str(0, "Authentication-Results: example.org; dkim=fail");
+            .insert_str(0, "Authentication-Results: example.org; dkim=fail\n");
 
         let received = alice.recv_msg(&sent).await;
 
@@ -717,7 +717,7 @@ Authentication-Results: box.hispanilandia.net; spf=pass smtp.mailfrom=adbenitez@
         loop {
             if let Some(mut sent) = bob2.pop_sent_msg_opt(Duration::ZERO).await {
                 sent.payload
-                    .insert_str(0, "Authentication-Results: example.org; dkim=fail");
+                    .insert_str(0, "Authentication-Results: example.org; dkim=fail\n");
                 alice.recv_msg(&sent).await;
             } else if let Some(sent) = alice.pop_sent_msg_opt(Duration::ZERO).await {
                 bob2.recv_msg(&sent).await;

src/blob.rs

@@ -222,7 +222,7 @@ impl<'a> BlobObject<'a> {
     /// to be lowercase.
     pub fn suffix(&self) -> Option<&str> {
         let ext = self.name.rsplit('.').next();
-        if ext == Some(&self.name) {
+        if ext == Some(self.name.as_str()) {
             None
         } else {
             ext

src/chat.rs

@@ -2188,7 +2188,7 @@ pub async fn send_videochat_invitation(context: &Context, chat_id: ChatId) -> Re
     let mut msg = Message::new(Viewtype::VideochatInvitation);
     msg.param.set(Param::WebrtcRoom, &instance);
     msg.text = Some(
-        stock_str::videochat_invite_msg_body(context, Message::parse_webrtc_instance(&instance).1)
+        stock_str::videochat_invite_msg_body(context, &Message::parse_webrtc_instance(&instance).1)
             .await,
     );
     send_msg(context, chat_id, &mut msg).await
@@ -2563,7 +2563,7 @@ pub async fn create_group_chat(
 
     let chat_id = ChatId::new(u32::try_from(row_id)?);
     if !is_contact_in_chat(context, chat_id, ContactId::SELF).await? {
-        add_to_chat_contacts_table(context, chat_id, ContactId::SELF).await?;
+        add_to_chat_contacts_table(context, chat_id, &[ContactId::SELF]).await?;
     }
 
     context.emit_msgs_changed_without_ids();
@@ -2624,19 +2624,25 @@ pub async fn create_broadcast_list(context: &Context) -> Result<ChatId> {
     Ok(chat_id)
 }
 
-/// Adds a contact to the `chats_contacts` table.
+/// Adds contacts to the `chats_contacts` table.
 pub(crate) async fn add_to_chat_contacts_table(
     context: &Context,
     chat_id: ChatId,
-    contact_id: ContactId,
+    contact_ids: &[ContactId],
 ) -> Result<()> {
     context
         .sql
-        .execute(
-            "INSERT INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)",
-            paramsv![chat_id, contact_id],
-        )
+        .transaction(move |transaction| {
+            for contact_id in contact_ids {
+                transaction.execute(
+                    "INSERT OR IGNORE INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)",
+                    paramsv![chat_id, contact_id],
+                )?;
+            }
+            Ok(())
+        })
         .await?;
+
     Ok(())
 }
 
@@ -2738,7 +2744,7 @@ pub(crate) async fn add_contact_to_chat_ex(
         if is_contact_in_chat(context, chat_id, contact_id).await? {
             return Ok(false);
         }
-        add_to_chat_contacts_table(context, chat_id, contact_id).await?;
+        add_to_chat_contacts_table(context, chat_id, &[contact_id]).await?;
     }
     if chat.typ == Chattype::Group && chat.is_promoted() {
         msg.viewtype = Viewtype::Text;
@@ -3005,7 +3011,7 @@ pub async fn set_chat_name(context: &Context, chat_id: ChatId, new_name: &str) -
 pub async fn set_chat_profile_image(
     context: &Context,
     chat_id: ChatId,
-    new_image: impl AsRef<str>, // XXX use PathBuf
+    new_image: &str, // XXX use PathBuf
 ) -> Result<()> {
     ensure!(!chat_id.is_special(), "Invalid chat ID");
     let mut chat = Chat::load_from_db(context, chat_id).await?;
@@ -3023,13 +3029,12 @@ pub async fn set_chat_profile_image(
     let mut msg = Message::new(Viewtype::Text);
     msg.param
         .set_int(Param::Cmd, SystemMessage::GroupImageChanged as i32);
-    if new_image.as_ref().is_empty() {
+    if new_image.is_empty() {
         chat.param.remove(Param::ProfileImage);
         msg.param.remove(Param::Arg);
         msg.text = Some(stock_str::msg_grp_img_deleted(context, ContactId::SELF).await);
     } else {
-        let mut image_blob =
-            BlobObject::new_from_path(context, Path::new(new_image.as_ref())).await?;
+        let mut image_blob = BlobObject::new_from_path(context, Path::new(new_image)).await?;
         image_blob.recode_to_avatar_size(context).await?;
         chat.param.set(Param::ProfileImage, image_blob.as_name());
         msg.param.set(Param::Arg, image_blob.as_name());

src/config.rs

@@ -194,20 +194,20 @@ pub enum Config {
 
 impl Context {
     pub async fn config_exists(&self, key: Config) -> Result<bool> {
-        Ok(self.sql.get_raw_config(key).await?.is_some())
+        Ok(self.sql.get_raw_config(key.as_ref()).await?.is_some())
     }
 
     /// Get a configuration key. Returns `None` if no value is set, and no default value found.
     pub async fn get_config(&self, key: Config) -> Result<Option<String>> {
         let value = match key {
             Config::Selfavatar => {
-                let rel_path = self.sql.get_raw_config(key).await?;
+                let rel_path = self.sql.get_raw_config(key.as_ref()).await?;
                 rel_path.map(|p| get_abs_path(self, &p).to_string_lossy().into_owned())
             }
             Config::SysVersion => Some((*DC_VERSION_STR).clone()),
             Config::SysMsgsizeMaxRecommended => Some(format!("{}", RECOMMENDED_FILE_SIZE)),
             Config::SysConfigKeys => Some(get_config_keys_string()),
-            _ => self.sql.get_raw_config(key).await?,
+            _ => self.sql.get_raw_config(key.as_ref()).await?,
         };
 
         if value.is_some() {
@@ -297,26 +297,30 @@ impl Context {
                     Some(value) => {
                         let mut blob = BlobObject::new_from_path(self, value.as_ref()).await?;
                         blob.recode_to_avatar_size(self).await?;
-                        self.sql.set_raw_config(key, Some(blob.as_name())).await?;
+                        self.sql
+                            .set_raw_config(key.as_ref(), Some(blob.as_name()))
+                            .await?;
                     }
                     None => {
-                        self.sql.set_raw_config(key, None).await?;
+                        self.sql.set_raw_config(key.as_ref(), None).await?;
                     }
                 }
                 self.emit_event(EventType::SelfavatarChanged);
             }
             Config::DeleteDeviceAfter => {
-                let ret = self.sql.set_raw_config(key, value).await;
+                let ret = self.sql.set_raw_config(key.as_ref(), value).await;
                 // Interrupt ephemeral loop to delete old messages immediately.
                 self.interrupt_ephemeral_task().await;
                 ret?
             }
             Config::Displayname => {
                 let value = value.map(improve_single_line_input);
-                self.sql.set_raw_config(key, value.as_deref()).await?;
+                self.sql
+                    .set_raw_config(key.as_ref(), value.as_deref())
+                    .await?;
             }
             _ => {
-                self.sql.set_raw_config(key, value).await?;
+                self.sql.set_raw_config(key.as_ref(), value).await?;
             }
         }
         Ok(())

src/configure.rs

@@ -87,7 +87,7 @@ impl Context {
                         self,
                         // We are using Anyhow's .context() and to show the
                         // inner error, too, we need the {:#}:
-                        format!("{:#}", err),
+                        &format!("{:#}", err),
                     )
                     .await
                 )
@@ -153,7 +153,7 @@ async fn on_configure_completed(
             if !addr_cmp(&new_addr, &old_addr) {
                 let mut msg = Message::new(Viewtype::Text);
                 msg.text =
-                    Some(stock_str::aeap_explanation_and_link(context, old_addr, new_addr).await);
+                    Some(stock_str::aeap_explanation_and_link(context, &old_addr, &new_addr).await);
                 chat::add_device_msg(context, None, Some(&mut msg))
                     .await
                     .ok_or_log_msg(context, "Cannot add AEAP explanation");
@@ -455,7 +455,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
 
     progress!(ctx, 910);
 
-    if ctx.get_config(Config::ConfiguredAddr).await?.as_deref() != Some(&param.addr) {
+    if ctx.get_config(Config::ConfiguredAddr).await?.as_deref() != Some(param.addr.as_str()) {
         // Switched account, all server UIDs we know are invalid
         job::schedule_resync(ctx).await?;
     }

src/contact.rs

@@ -229,7 +229,7 @@ pub enum Origin {
     /// set on Bob's side for contacts scanned and verified from a QR code. Only means the contact has once been established using the "securejoin" procedure in the past, getting the current key verification status requires calling contact_is_verified() !
     SecurejoinJoined = 0x0200_0000,
 
-    /// contact added mannually by create_contact(), this should be the largest origin as otherwise the user cannot modify the names
+    /// contact added manually by create_contact(), this should be the largest origin as otherwise the user cannot modify the names
     ManuallyCreated = 0x0400_0000,
 }
 
@@ -455,7 +455,7 @@ impl Contact {
     /// - "row_authname": name as authorized from a contact, set only through a From-header
     /// Depending on the origin, both, "row_name" and "row_authname" are updated from "name".
     ///
-    /// Returns the contact_id and a `Modifier` value indicating if a modification occured.
+    /// Returns the contact_id and a `Modifier` value indicating if a modification occurred.
     pub(crate) async fn add_or_lookup(
         context: &Context,
         name: &str,
@@ -945,8 +945,8 @@ impl Contact {
     }
 
     /// Delete a contact so that it disappears from the corresponding lists.
-    //  Depending on whether there are ongoing chats, deletion is done by physical deletion or hiding.
-    //  The contact is deleted from the local device.
+    /// Depending on whether there are ongoing chats, deletion is done by physical deletion or hiding.
+    /// The contact is deleted from the local device.
     ///
     /// May result in a `#DC_EVENT_CONTACTS_CHANGED` event.
     pub async fn delete(context: &Context, contact_id: ContactId) -> Result<()> {
@@ -1517,7 +1517,7 @@ impl RecentlySeenLoop {
             if let Ok(duration) = until.duration_since(now) {
                 info!(
                     context,
-                    "Recently seen loop waiting for {} or interupt",
+                    "Recently seen loop waiting for {} or interrupt",
                     duration_to_str(duration)
                 );
 
@@ -1731,7 +1731,7 @@ mod tests {
         );
         assert_eq!(Contact::add_address_book(&t, book).await.unwrap(), 4);
 
-        // check first added contact, this modifies authname beacuse it is empty
+        // check first added contact, this modifies authname because it is empty
         let (contact_id, sth_modified) =
             Contact::add_or_lookup(&t, "bla foo", "one@eins.org", Origin::IncomingUnknownTo)
                 .await

src/decrypt.rs

@@ -4,9 +4,8 @@ use std::collections::HashSet;
 
 use anyhow::{Context as _, Result};
 use mailparse::ParsedMail;
-use mailparse::SingleInfo;
 
-use crate::aheader::Aheader;
+use crate::aheader::{Aheader, EncryptPreference};
 use crate::authres;
 use crate::authres::handle_authres;
 use crate::contact::addr_cmp;
@@ -56,22 +55,23 @@ pub async fn try_decrypt(
     .await
 }
 
-pub async fn prepare_decryption(
+pub(crate) async fn prepare_decryption(
     context: &Context,
     mail: &ParsedMail<'_>,
-    from: &[SingleInfo],
+    from: &str,
     message_time: i64,
+    is_thunderbird: bool,
 ) -> Result<DecryptionInfo> {
-    let from = if let Some(f) = from.first() {
-        &f.addr
-    } else {
-        return Ok(DecryptionInfo::default());
-    };
-
-    let autocrypt_header = Aheader::from_headers(from, &mail.headers)
+    let mut autocrypt_header = Aheader::from_headers(from, &mail.headers)
         .ok_or_log_msg(context, "Failed to parse Autocrypt header")
         .flatten();
 
+    if is_thunderbird {
+        if let Some(autocrypt_header) = &mut autocrypt_header {
+            autocrypt_header.prefer_encrypt = EncryptPreference::Mutual;
+        }
+    }
+
     let dkim_results = handle_authres(context, mail, from, message_time).await?;
 
     let peerstate = get_autocrypt_peerstate(
@@ -306,7 +306,7 @@ pub(crate) async fn get_autocrypt_peerstate(
             if addr_cmp(&peerstate.addr, from) {
                 if allow_change {
                     peerstate.apply_header(header, message_time);
-                    peerstate.save_to_db(&context.sql, false).await?;
+                    peerstate.save_to_db(&context.sql).await?;
                 } else {
                     info!(
                         context,
@@ -322,7 +322,7 @@ pub(crate) async fn get_autocrypt_peerstate(
             // to the database.
         } else {
             let p = Peerstate::from_header(header, message_time);
-            p.save_to_db(&context.sql, true).await?;
+            p.save_to_db(&context.sql).await?;
             peerstate = Some(p);
         }
     } else {

src/e2ee.rs

@@ -147,7 +147,6 @@ mod tests {
     use crate::chat;
     use crate::message::{Message, Viewtype};
     use crate::param::Param;
-    use crate::peerstate::ToSave;
     use crate::test_utils::{bob_keypair, TestContext};
 
     use super::*;
@@ -297,7 +296,6 @@ Sent with my Delta Chat Messenger: https://delta.chat";
             gossip_key_fingerprint: Some(pub_key.fingerprint()),
             verified_key: Some(pub_key.clone()),
             verified_key_fingerprint: Some(pub_key.fingerprint()),
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         };
         vec![(Some(peerstate), addr)]

src/ephemeral.rs

@@ -226,13 +226,13 @@ pub(crate) async fn stock_ephemeral_timer_changed(
         Timer::Disabled => stock_str::msg_ephemeral_timer_disabled(context, from_id).await,
         Timer::Enabled { duration } => match duration {
             0..=59 => {
-                stock_str::msg_ephemeral_timer_enabled(context, timer.to_string(), from_id).await
+                stock_str::msg_ephemeral_timer_enabled(context, &timer.to_string(), from_id).await
             }
             60 => stock_str::msg_ephemeral_timer_minute(context, from_id).await,
             61..=3599 => {
                 stock_str::msg_ephemeral_timer_minutes(
                     context,
-                    format!("{}", (f64::from(duration) / 6.0).round() / 10.0),
+                    &format!("{}", (f64::from(duration) / 6.0).round() / 10.0),
                     from_id,
                 )
                 .await
@@ -241,7 +241,7 @@ pub(crate) async fn stock_ephemeral_timer_changed(
             3601..=86399 => {
                 stock_str::msg_ephemeral_timer_hours(
                     context,
-                    format!("{}", (f64::from(duration) / 360.0).round() / 10.0),
+                    &format!("{}", (f64::from(duration) / 360.0).round() / 10.0),
                     from_id,
                 )
                 .await
@@ -250,7 +250,7 @@ pub(crate) async fn stock_ephemeral_timer_changed(
             86401..=604_799 => {
                 stock_str::msg_ephemeral_timer_days(
                     context,
-                    format!("{}", (f64::from(duration) / 8640.0).round() / 10.0),
+                    &format!("{}", (f64::from(duration) / 8640.0).round() / 10.0),
                     from_id,
                 )
                 .await
@@ -259,7 +259,7 @@ pub(crate) async fn stock_ephemeral_timer_changed(
             _ => {
                 stock_str::msg_ephemeral_timer_weeks(
                     context,
-                    format!("{}", (f64::from(duration) / 60480.0).round() / 10.0),
+                    &format!("{}", (f64::from(duration) / 60480.0).round() / 10.0),
                     from_id,
                 )
                 .await

src/format_flowed.rs

@@ -48,7 +48,7 @@ fn format_line_flowed(line: &str, prefix: &str) -> String {
             after_space = false;
         }
     }
-    result + &buffer
+    result + buffer.as_str()
 }
 
 /// Returns text formatted according to RFC 3767 (format=flowed).

src/imap.rs

@@ -56,6 +56,8 @@ use session::Session;
 
 use self::select_folder::NewlySelected;
 
+pub(crate) const GENERATED_PREFIX: &str = "GEN_";
+
 #[derive(Debug, Display, Clone, Copy, PartialEq, Eq)]
 pub enum ImapActionResult {
     Failed,
@@ -780,8 +782,7 @@ impl Imap {
         let show_emails = ShowEmails::from_i32(context.get_config_int(Config::ShowEmails).await?)
             .unwrap_or_default();
         let download_limit = context.download_limit().await?;
-        let mut uids_fetch_fully = Vec::with_capacity(msgs.len());
-        let mut uids_fetch_partially = Vec::with_capacity(msgs.len());
+        let mut uids_fetch = Vec::<(_, bool /* partially? */)>::with_capacity(msgs.len() + 1);
         let mut uid_message_ids = BTreeMap::new();
         let mut largest_uid_skipped = None;
 
@@ -796,7 +797,7 @@ impl Imap {
             };
 
             // Get the Message-ID or generate a fake one to identify the message in the database.
-            let message_id = prefetch_get_message_id(&headers).unwrap_or_else(create_id);
+            let message_id = prefetch_get_or_create_message_id(&headers);
 
             let target = match target_folder(context, folder, is_spam_folder, &headers).await? {
                 Some(config) => match context.get_config(config).await? {
@@ -840,14 +841,11 @@ impl Imap {
                 .await?
             {
                 match download_limit {
-                    Some(download_limit) => {
-                        if fetch_response.size.unwrap_or_default() > download_limit {
-                            uids_fetch_partially.push(uid);
-                        } else {
-                            uids_fetch_fully.push(uid)
-                        }
-                    }
-                    None => uids_fetch_fully.push(uid),
+                    Some(download_limit) => uids_fetch.push((
+                        uid,
+                        fetch_response.size.unwrap_or_default() > download_limit,
+                    )),
+                    None => uids_fetch.push((uid, false)),
                 }
                 uid_message_ids.insert(uid, message_id);
             } else {
@@ -855,33 +853,37 @@ impl Imap {
             }
         }
 
-        if !uids_fetch_fully.is_empty() || !uids_fetch_partially.is_empty() {
+        if !uids_fetch.is_empty() {
             self.connectivity.set_working(context).await;
         }
 
         // Actually download messages.
-        let (largest_uid_fully_fetched, mut received_msgs) = self
-            .fetch_many_msgs(
-                context,
-                folder,
-                uids_fetch_fully,
-                &uid_message_ids,
-                false,
-                fetch_existing_msgs,
-            )
-            .await?;
-
-        let (largest_uid_partially_fetched, received_msgs_2) = self
-            .fetch_many_msgs(
-                context,
-                folder,
-                uids_fetch_partially,
-                &uid_message_ids,
-                true,
-                fetch_existing_msgs,
-            )
-            .await?;
-        received_msgs.extend(received_msgs_2);
+        let mut largest_uid_fetched: u32 = 0;
+        let mut received_msgs = Vec::with_capacity(uids_fetch.len());
+        let mut uids_fetch_in_batch = Vec::with_capacity(max(uids_fetch.len(), 1));
+        let mut fetch_partially = false;
+        uids_fetch.push((0, !uids_fetch.last().unwrap_or(&(0, false)).1));
+        for (uid, fp) in uids_fetch {
+            if fp != fetch_partially {
+                let (largest_uid_fetched_in_batch, received_msgs_in_batch) = self
+                    .fetch_many_msgs(
+                        context,
+                        folder,
+                        uids_fetch_in_batch.split_off(0),
+                        &uid_message_ids,
+                        fetch_partially,
+                        fetch_existing_msgs,
+                    )
+                    .await?;
+                received_msgs.extend(received_msgs_in_batch);
+                largest_uid_fetched = max(
+                    largest_uid_fetched,
+                    largest_uid_fetched_in_batch.unwrap_or(0),
+                );
+                fetch_partially = fp;
+            }
+            uids_fetch_in_batch.push(uid);
+        }
 
         // determine which uid_next to use to update to
         // receive_imf() returns an `Err` value only on recoverable errors, otherwise it just logs an error.
@@ -889,13 +891,7 @@ impl Imap {
 
         // So: Update the uid_next to the largest uid that did NOT recoverably fail. Not perfect because if there was
         // another message afterwards that succeeded, we will not retry. The upside is that we will not retry an infinite amount of times.
-        let largest_uid_without_errors = max(
-            max(
-                largest_uid_fully_fetched.unwrap_or(0),
-                largest_uid_partially_fetched.unwrap_or(0),
-            ),
-            largest_uid_skipped.unwrap_or(0),
-        );
+        let largest_uid_without_errors = max(largest_uid_fetched, largest_uid_skipped.unwrap_or(0));
         let new_uid_next = largest_uid_without_errors + 1;
 
         if new_uid_next > old_uid_next {
@@ -1284,7 +1280,7 @@ impl Imap {
                 let msg = fetch?;
                 match get_fetch_headers(&msg) {
                     Ok(headers) => {
-                        if let Some(from) = mimeparser::get_from(&headers).first() {
+                        if let Some(from) = mimeparser::get_from(&headers) {
                             if context.is_self_addr(&from.addr).await? {
                                 result.extend(mimeparser::get_recipients(&headers));
                             }
@@ -1368,7 +1364,9 @@ impl Imap {
 
     /// Fetches a list of messages by server UID.
     ///
-    /// Returns the last uid fetch successfully and the info about each downloaded message.
+    /// Returns the last UID fetched successfully and the info about each downloaded message.
+    /// If the message is incorrect or there is a failure to write a message to the database,
+    /// it is skipped and the error is logged.
     pub(crate) async fn fetch_many_msgs(
         &mut self,
         context: &Context,
@@ -1454,7 +1452,7 @@ impl Imap {
                     .context("we checked that message has body right above, but it has vanished")?;
                 let is_seen = msg.flags().any(|flag| flag == Flag::Seen);
 
-                let rfc724_mid = if let Some(rfc724_mid) = &uid_message_ids.get(&server_uid) {
+                let rfc724_mid = if let Some(rfc724_mid) = uid_message_ids.get(&server_uid) {
                     rfc724_mid
                 } else {
                     warn!(
@@ -1462,7 +1460,7 @@ impl Imap {
                         "No Message-ID corresponding to UID {} passed in uid_messsage_ids",
                         server_uid
                     );
-                    ""
+                    continue;
                 };
                 match receive_imf_inner(
                     &context,
@@ -1478,12 +1476,12 @@ impl Imap {
                         if let Some(m) = received_msg {
                             received_msgs.push(m);
                         }
-                        last_uid = Some(server_uid)
                     }
                     Err(err) => {
                         warn!(context, "receive_imf error: {:#}", err);
                     }
                 };
+                last_uid = Some(server_uid)
             }
         }
 
@@ -1758,9 +1756,13 @@ async fn should_move_out_of_spam(
             return Ok(false);
         }
     } else {
+        let from = match mimeparser::get_from(headers) {
+            Some(f) => f,
+            None => return Ok(false),
+        };
         // No chat found.
         let (from_id, blocked_contact, _origin) =
-            from_field_to_contact_id(context, &mimeparser::get_from(headers), true).await?;
+            from_field_to_contact_id(context, &from, true).await?;
         if blocked_contact {
             // Contact is blocked, leave the message in spam.
             return Ok(false);
@@ -1949,15 +1951,20 @@ fn get_folder_meaning_by_name(folder_name: &str) -> FolderMeaning {
 
 fn get_folder_meaning(folder_name: &Name) -> FolderMeaning {
     for attr in folder_name.attributes() {
-        if let NameAttribute::Extension(ref label) = attr {
-            match label.as_ref() {
-                "\\Trash" => return FolderMeaning::Other,
-                "\\Sent" => return FolderMeaning::Sent,
-                "\\Spam" | "\\Junk" => return FolderMeaning::Spam,
-                "\\Drafts" => return FolderMeaning::Drafts,
-                "\\All" | "\\Important" | "\\Flagged" => return FolderMeaning::Virtual,
-                _ => {}
-            };
+        match attr {
+            NameAttribute::Trash => return FolderMeaning::Other,
+            NameAttribute::Sent => return FolderMeaning::Sent,
+            NameAttribute::Junk => return FolderMeaning::Spam,
+            NameAttribute::Drafts => return FolderMeaning::Drafts,
+            NameAttribute::All | NameAttribute::Flagged => return FolderMeaning::Virtual,
+            NameAttribute::Extension(ref label) => {
+                match label.as_ref() {
+                    "\\Spam" => return FolderMeaning::Spam,
+                    "\\Important" => return FolderMeaning::Virtual,
+                    _ => {}
+                };
+            }
+            _ => {}
         }
     }
     FolderMeaning::Unknown
@@ -1975,13 +1982,15 @@ fn get_fetch_headers(prefetch_msg: &Fetch) -> Result<Vec<mailparse::MailHeader>>
 }
 
 fn prefetch_get_message_id(headers: &[mailparse::MailHeader]) -> Option<String> {
-    if let Some(message_id) = headers.get_header_value(HeaderDef::XMicrosoftOriginalMessageId) {
-        crate::mimeparser::parse_message_id(&message_id).ok()
-    } else if let Some(message_id) = headers.get_header_value(HeaderDef::MessageId) {
-        crate::mimeparser::parse_message_id(&message_id).ok()
-    } else {
-        None
-    }
+    headers
+        .get_header_value(HeaderDef::XMicrosoftOriginalMessageId)
+        .or_else(|| headers.get_header_value(HeaderDef::MessageId))
+        .and_then(|msgid| mimeparser::parse_message_id(&msgid).ok())
+}
+
+pub(crate) fn prefetch_get_or_create_message_id(headers: &[mailparse::MailHeader]) -> String {
+    prefetch_get_message_id(headers)
+        .unwrap_or_else(|| format!("{}{}", GENERATED_PREFIX, create_id()))
 }
 
 /// Returns chat by prefetched headers.
@@ -2038,8 +2047,12 @@ pub(crate) async fn prefetch_should_download(
         .get_header_value(HeaderDef::AutocryptSetupMessage)
         .is_some();
 
+    let from = match mimeparser::get_from(headers) {
+        Some(f) => f,
+        None => return Ok(false),
+    };
     let (_from_id, blocked_contact, origin) =
-        from_field_to_contact_id(context, &mimeparser::get_from(headers), true).await?;
+        from_field_to_contact_id(context, &from, 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())
 

src/imex.rs

@@ -5,11 +5,12 @@ use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 
 use ::pgp::types::KeyTrait;
-use anyhow::{bail, ensure, format_err, Context as _, Result};
-use futures::StreamExt;
+use anyhow::{anyhow, bail, ensure, format_err, Context as _, Result};
+use futures::{StreamExt, TryStreamExt};
 use futures_lite::FutureExt;
 use rand::{thread_rng, Rng};
 use tokio::fs::{self, File};
+use tokio::io::AsyncWriteExt;
 use tokio_tar::Archive;
 
 use crate::blob::BlobObject;
@@ -106,6 +107,188 @@ pub async fn imex(
     res
 }
 
+/// Receives a backup, as sent from `send_backup`.
+///
+/// Only one receive-progress can run at the same time.
+/// To cancel a receive-progress, drop the future returned by this function.
+pub async fn receive_backup(
+    context: &Context,
+    ticket_bytes: Vec<u8>,
+    passphrase: Option<String>,
+) -> Result<()> {
+    let cancel = context.alloc_ongoing().await?;
+
+    let res = receive_backup_inner(context, ticket_bytes, passphrase.unwrap_or_default())
+        .race(async {
+            cancel.recv().await.ok();
+            Err(format_err!("canceled"))
+        })
+        .await;
+
+    context.free_ongoing().await;
+
+    if let Err(err) = res.as_ref() {
+        // We are using Anyhow's .context() and to show the inner error, too, we need the {:#}:
+        error!(context, "IMEX failed to complete: {:#}", err);
+        context.emit_event(EventType::ImexProgress(0));
+    } else {
+        info!(context, "IMEX successfully completed");
+        context.emit_event(EventType::ImexProgress(1000));
+    }
+
+    res
+}
+
+async fn receive_backup_inner(
+    context: &Context,
+    ticket_bytes: Vec<u8>,
+    passphrase: String,
+) -> Result<()> {
+    use iroh_share::{Receiver, Ticket};
+    ensure!(
+        !context.is_configured().await?,
+        "Cannot import backups to accounts in use."
+    );
+    ensure!(
+        context.scheduler.read().await.is_none(),
+        "cannot import backup, IO is running"
+    );
+    let ticket = Ticket::from_bytes(&ticket_bytes)?;
+
+    let recv_dir = tempfile::tempdir().unwrap();
+    let recv_db = recv_dir.path().join("db");
+    let port = port_check::free_local_port()
+        .ok_or_else(|| anyhow!("failed to find free local port to bind to"))?;
+
+    let receiver = Receiver::new(port, &recv_db)
+        .await
+        .context("failed to create receiver")?;
+    let mut receiver_transfer = receiver
+        .transfer_from_ticket(&ticket)
+        .await
+        .context("failed to read transfer")?;
+    let data = receiver_transfer.recv().await?;
+    let mut progress = receiver_transfer.progress()?;
+
+    context.sql.config_cache.write().await.clear();
+
+    // progress report
+    let ctx = context.clone();
+    let progress_task = tokio::spawn(async move {
+        let mut last_progress = 0;
+        while let Some(ev) = progress.next().await {
+            match ev {
+                Ok(iroh_share::ProgressEvent::Piece { index, total }) => {
+                    let progress = 1000 * index / total;
+                    if progress != last_progress && progress < 1000 {
+                        ctx.emit_event(EventType::ImexProgress(progress));
+                        last_progress = progress;
+                    }
+                }
+                Err(err) => {
+                    error!(ctx, "IMEX receive backup failed to complete: {}", err);
+                    ctx.emit_event(EventType::ImexProgress(0));
+                }
+            }
+        }
+    });
+
+    let out = context.get_blobdir();
+
+    let mut read_dir_stream = data
+        .read_dir()?
+        .ok_or_else(|| anyhow::anyhow!("unexpected data structure"))?;
+
+    while let Some(link) = read_dir_stream.next().await {
+        let link = link?;
+        let file_content = data.read_file(&link).await?;
+        let name = link.name.unwrap_or_default();
+        let path = out.join(&name);
+
+        let file = tokio::fs::File::create(&path)
+            .await
+            .with_context(|| format!("create file: {}", path.display()))?;
+        let mut file = tokio::io::BufWriter::new(file);
+        let mut content = file_content.pretty()?;
+        tokio::io::copy(&mut content, &mut file)
+            .await
+            .context("copy")?;
+        file.flush().await?;
+
+        if name == DBFILE_BACKUP_NAME {
+            let unpacked_database = context.get_blobdir().join(DBFILE_BACKUP_NAME);
+            context
+                .sql
+                .import(&unpacked_database, passphrase.clone())
+                .await
+                .context("cannot import unpacked database")?;
+            fs::remove_file(unpacked_database)
+                .await
+                .context("cannot remove unpacked database")?;
+        } else {
+            // nothing to do, unpacked directly into the blobs dir
+        }
+    }
+
+    progress_task.await?;
+    receiver_transfer.finish().await?;
+
+    info!(context, "Received all data, written to: {}", out.display());
+
+    Ok(())
+}
+
+/// Send a backup.
+///
+/// Only one send-progress can run at the same time.
+/// To cancel a send-progress, drop the future returned by this function.
+pub async fn send_backup(
+    context: &Context,
+    path: &Path,
+    passphrase: Option<String>,
+) -> Result<iroh_share::SenderTransfer> {
+    let cancel = context.alloc_ongoing().await?;
+
+    let res = send_backup_inner(context, path, passphrase)
+        .race(async {
+            cancel.recv().await.ok();
+            Err(format_err!("canceled"))
+        })
+        .await;
+
+    context.free_ongoing().await;
+
+    if let Err(err) = res.as_ref() {
+        // We are using Anyhow's .context() and to show the inner error, too, we need the {:#}:
+        error!(context, "Send backup failed to complete: {:#}", err);
+        context.emit_event(EventType::ImexProgress(0));
+    } else {
+        info!(context, "Send backup successfully completed");
+        context.emit_event(EventType::ImexProgress(1000));
+    }
+
+    res
+}
+
+async fn send_backup_inner(
+    context: &Context,
+    path: &Path,
+    passphrase: Option<String>,
+) -> Result<iroh_share::SenderTransfer> {
+    info!(context, "Send backup dir: {}", path.display());
+    ensure!(context.sql.is_open().await, "Database not opened.");
+    context.emit_event(EventType::ImexProgress(10));
+
+    // before we export anything, make sure the private key exists
+    if e2ee::ensure_secret_key_exists(context).await.is_err() {
+        bail!("Cannot create private key or private key not available.");
+    } else {
+        create_folder(context, &path).await?;
+    }
+
+    export_backup_iroh(context, path, passphrase.unwrap_or_default()).await
+}
+
 /// Returns the filename of the backup found (otherwise an error)
 pub async fn has_backup(_context: &Context, dir_name: &Path) -> Result<String> {
     let mut dir_iter = tokio::fs::read_dir(dir_name).await?;
@@ -478,7 +661,8 @@ async fn import_backup(
 /// it can be renamed to dest_path. This guarantees that the backup is complete.
 fn get_next_backup_path(folder: &Path, backup_time: i64) -> Result<(PathBuf, PathBuf, PathBuf)> {
     let folder = PathBuf::from(folder);
-    let stem = chrono::NaiveDateTime::from_timestamp(backup_time, 0)
+    let stem = chrono::NaiveDateTime::from_timestamp_opt(backup_time, 0)
+        .unwrap()
         // Don't change this file name format, in `dc_imex_has_backup` we use string comparison to determine which backup is newer:
         .format("delta-chat-backup-%Y-%m-%d")
         .to_string();
@@ -608,6 +792,135 @@ async fn export_backup_inner(
     Ok(())
 }
 
+async fn export_backup_iroh(
+    context: &Context,
+    dir: &Path,
+    passphrase: String,
+) -> Result<iroh_share::SenderTransfer> {
+    // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
+    let now = time();
+    let (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, now)?;
+    let sender_db_path = dir.join("iroh_db");
+    let _d1 = DeleteOnDrop(temp_db_path.clone());
+    let _d2 = DeleteOnDrop(temp_path.clone());
+    let _d3 = DeleteOnDrop(sender_db_path.clone());
+
+    context
+        .sql
+        .set_raw_config_int("backup_time", now as i32)
+        .await?;
+    sql::housekeeping(context).await.ok_or_log(context);
+
+    context
+        .sql
+        .execute("VACUUM;", paramsv![])
+        .await
+        .map_err(|e| warn!(context, "Vacuum failed, exporting anyway {}", e))
+        .ok();
+
+    ensure!(
+        context.scheduler.read().await.is_none(),
+        "cannot export backup, IO is running"
+    );
+
+    info!(
+        context,
+        "Backup '{}' to '{}'.",
+        context.get_dbfile().display(),
+        dest_path.display(),
+    );
+
+    context
+        .sql
+        .export(&temp_db_path, passphrase)
+        .await
+        .with_context(|| format!("failed to backup plaintext database to {:?}", temp_db_path))?;
+
+    let res = export_backup_iroh_inner(context, &temp_db_path, &temp_path).await;
+
+    match res {
+        Ok(dir_builder) => {
+            let port = port_check::free_local_port()
+                .ok_or_else(|| anyhow!("failed to find free local port to bind to"))?;
+            let sender = iroh_share::Sender::new(port, &sender_db_path).await?;
+            let transfer = sender.transfer_from_dir_builder(dir_builder).await?;
+
+            Ok(transfer)
+        }
+        Err(e) => {
+            error!(context, "backup failed: {}", e);
+            Err(e)
+        }
+    }
+}
+
+async fn export_backup_iroh_inner(
+    context: &Context,
+    temp_db_path: &Path,
+    temp_path: &Path,
+) -> Result<iroh_resolver::unixfs_builder::DirectoryBuilder> {
+    use iroh_resolver::unixfs_builder::{DirectoryBuilder, FileBuilder};
+
+    let mut dir_builder = DirectoryBuilder::new();
+    dir_builder.name(
+        temp_path
+            .file_name()
+            .map(|s| s.to_string_lossy())
+            .unwrap_or_default(),
+    );
+
+    {
+        let db_content = tokio::fs::File::open(temp_db_path).await?;
+        let file = FileBuilder::new()
+            .name(DBFILE_BACKUP_NAME)
+            .content_reader(db_content)
+            .build()
+            .await?;
+
+        dir_builder.add_file(file);
+    }
+
+    let read_dir: Vec<_> =
+        tokio_stream::wrappers::ReadDirStream::new(fs::read_dir(context.get_blobdir()).await?)
+            .try_collect()
+            .await?;
+    let count = read_dir.len();
+    let mut written_files = 0;
+
+    let mut last_progress = 0;
+    for entry in read_dir.into_iter() {
+        let name = entry.file_name();
+        if !entry.file_type().await?.is_file() {
+            warn!(
+                context,
+                "Export: Found dir entry {} that is not a file, ignoring",
+                name.to_string_lossy()
+            );
+            continue;
+        }
+        let file_content = File::open(entry.path()).await?;
+
+        {
+            let file = FileBuilder::new()
+                .name(name.to_string_lossy().to_owned())
+                .content_reader(file_content)
+                .build()
+                .await?;
+            dir_builder.add_file(file);
+        }
+
+        written_files += 1;
+        let progress = 1000 * written_files / count;
+        if progress != last_progress && progress > 10 && progress < 1000 {
+            // We already emitted ImexProgress(10) above
+            context.emit_event(EventType::ImexProgress(progress));
+            last_progress = progress;
+        }
+    }
+
+    Ok(dir_builder)
+}
+
 /*******************************************************************************
  * Classic key import
  ******************************************************************************/

src/location.rs

@@ -476,7 +476,8 @@ pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)
 
 fn get_kml_timestamp(utc: i64) -> String {
     // Returns a string formatted as YYYY-MM-DDTHH:MM:SSZ. The trailing `Z` indicates UTC.
-    chrono::NaiveDateTime::from_timestamp(utc, 0)
+    chrono::NaiveDateTime::from_timestamp_opt(utc, 0)
+        .unwrap()
         .format("%Y-%m-%dT%H:%M:%SZ")
         .to_string()
 }

src/login_param.rs

@@ -169,7 +169,7 @@ impl LoginParam {
     async fn from_database(context: &Context, prefix: &str) -> Result<Self> {
         let sql = &context.sql;
 
-        let key = format!("{}addr", prefix);
+        let key = &format!("{}addr", prefix);
         let addr = sql
             .get_raw_config(key)
             .await?
@@ -177,26 +177,26 @@ impl LoginParam {
             .trim()
             .to_string();
 
-        let key = format!("{}mail_server", prefix);
+        let key = &format!("{}mail_server", prefix);
         let mail_server = sql.get_raw_config(key).await?.unwrap_or_default();
 
-        let key = format!("{}mail_port", prefix);
+        let key = &format!("{}mail_port", prefix);
         let mail_port = sql.get_raw_config_int(key).await?.unwrap_or_default();
 
-        let key = format!("{}mail_user", prefix);
+        let key = &format!("{}mail_user", prefix);
         let mail_user = sql.get_raw_config(key).await?.unwrap_or_default();
 
-        let key = format!("{}mail_pw", prefix);
+        let key = &format!("{}mail_pw", prefix);
         let mail_pw = sql.get_raw_config(key).await?.unwrap_or_default();
 
-        let key = format!("{}mail_security", prefix);
+        let key = &format!("{}mail_security", prefix);
         let mail_security = sql
             .get_raw_config_int(key)
             .await?
             .and_then(num_traits::FromPrimitive::from_i32)
             .unwrap_or_default();
 
-        let key = format!("{}imap_certificate_checks", prefix);
+        let key = &format!("{}imap_certificate_checks", prefix);
         let imap_certificate_checks =
             if let Some(certificate_checks) = sql.get_raw_config_int(key).await? {
                 num_traits::FromPrimitive::from_i32(certificate_checks).unwrap()
@@ -204,26 +204,26 @@ impl LoginParam {
                 Default::default()
             };
 
-        let key = format!("{}send_server", prefix);
+        let key = &format!("{}send_server", prefix);
         let send_server = sql.get_raw_config(key).await?.unwrap_or_default();
 
-        let key = format!("{}send_port", prefix);
+        let key = &format!("{}send_port", prefix);
         let send_port = sql.get_raw_config_int(key).await?.unwrap_or_default();
 
-        let key = format!("{}send_user", prefix);
+        let key = &format!("{}send_user", prefix);
         let send_user = sql.get_raw_config(key).await?.unwrap_or_default();
 
-        let key = format!("{}send_pw", prefix);
+        let key = &format!("{}send_pw", prefix);
         let send_pw = sql.get_raw_config(key).await?.unwrap_or_default();
 
-        let key = format!("{}send_security", prefix);
+        let key = &format!("{}send_security", prefix);
         let send_security = sql
             .get_raw_config_int(key)
             .await?
             .and_then(num_traits::FromPrimitive::from_i32)
             .unwrap_or_default();
 
-        let key = format!("{}smtp_certificate_checks", prefix);
+        let key = &format!("{}smtp_certificate_checks", prefix);
         let smtp_certificate_checks =
             if let Some(certificate_checks) = sql.get_raw_config_int(key).await? {
                 num_traits::FromPrimitive::from_i32(certificate_checks).unwrap_or_default()
@@ -231,11 +231,11 @@ impl LoginParam {
                 Default::default()
             };
 
-        let key = format!("{}server_flags", prefix);
+        let key = &format!("{}server_flags", prefix);
         let server_flags = sql.get_raw_config_int(key).await?.unwrap_or_default();
         let oauth2 = matches!(server_flags & DC_LP_AUTH_FLAGS, DC_LP_AUTH_OAUTH2);
 
-        let key = format!("{}provider", prefix);
+        let key = &format!("{}provider", prefix);
         let provider = sql
             .get_raw_config(key)
             .await?
@@ -275,50 +275,50 @@ impl LoginParam {
 
         context.set_primary_self_addr(&self.addr).await?;
 
-        let key = format!("{}mail_server", prefix);
+        let key = &format!("{}mail_server", prefix);
         sql.set_raw_config(key, Some(&self.imap.server)).await?;
 
-        let key = format!("{}mail_port", prefix);
+        let key = &format!("{}mail_port", prefix);
         sql.set_raw_config_int(key, i32::from(self.imap.port))
             .await?;
 
-        let key = format!("{}mail_user", prefix);
+        let key = &format!("{}mail_user", prefix);
         sql.set_raw_config(key, Some(&self.imap.user)).await?;
 
-        let key = format!("{}mail_pw", prefix);
+        let key = &format!("{}mail_pw", prefix);
         sql.set_raw_config(key, Some(&self.imap.password)).await?;
 
-        let key = format!("{}mail_security", prefix);
+        let key = &format!("{}mail_security", prefix);
         sql.set_raw_config_int(key, self.imap.security as i32)
             .await?;
 
-        let key = format!("{}imap_certificate_checks", prefix);
+        let key = &format!("{}imap_certificate_checks", prefix);
         sql.set_raw_config_int(key, self.imap.certificate_checks as i32)
             .await?;
 
-        let key = format!("{}send_server", prefix);
+        let key = &format!("{}send_server", prefix);
         sql.set_raw_config(key, Some(&self.smtp.server)).await?;
 
-        let key = format!("{}send_port", prefix);
+        let key = &format!("{}send_port", prefix);
         sql.set_raw_config_int(key, i32::from(self.smtp.port))
             .await?;
 
-        let key = format!("{}send_user", prefix);
+        let key = &format!("{}send_user", prefix);
         sql.set_raw_config(key, Some(&self.smtp.user)).await?;
 
-        let key = format!("{}send_pw", prefix);
+        let key = &format!("{}send_pw", prefix);
         sql.set_raw_config(key, Some(&self.smtp.password)).await?;
 
-        let key = format!("{}send_security", prefix);
+        let key = &format!("{}send_security", prefix);
         sql.set_raw_config_int(key, self.smtp.security as i32)
             .await?;
 
-        let key = format!("{}smtp_certificate_checks", prefix);
+        let key = &format!("{}smtp_certificate_checks", prefix);
         sql.set_raw_config_int(key, self.smtp.certificate_checks as i32)
             .await?;
 
         // The OAuth2 flag is either set for both IMAP and SMTP or not at all.
-        let key = format!("{}server_flags", prefix);
+        let key = &format!("{}server_flags", prefix);
         let server_flags = match self.imap.oauth2 {
             true => DC_LP_AUTH_OAUTH2,
             false => DC_LP_AUTH_NORMAL,
@@ -326,7 +326,7 @@ impl LoginParam {
         sql.set_raw_config_int(key, server_flags).await?;
 
         if let Some(provider) = self.provider {
-            let key = format!("{}provider", prefix);
+            let key = &format!("{}provider", prefix);
             sql.set_raw_config(key, Some(provider.id)).await?;
         }
 

src/mimefactory.rs

@@ -429,7 +429,7 @@ impl<'a> MimeFactory<'a> {
                     }
                 }
 
-                let self_name = match context.get_config(Config::Displayname).await? {
+                let self_name = &match context.get_config(Config::Displayname).await? {
                     Some(name) => name,
                     None => context.get_config(Config::Addr).await?.unwrap_or_default(),
                 };
@@ -531,7 +531,9 @@ impl<'a> MimeFactory<'a> {
             .push(Header::new("Subject".into(), encoded_subject));
 
         let date = chrono::Utc
-            .from_local_datetime(&chrono::NaiveDateTime::from_timestamp(self.timestamp, 0))
+            .from_local_datetime(
+                &chrono::NaiveDateTime::from_timestamp_opt(self.timestamp, 0).unwrap(),
+            )
             .unwrap()
             .to_rfc2822();
         headers.unprotected.push(Header::new("Date".into(), date));
@@ -1259,7 +1261,7 @@ impl<'a> MimeFactory<'a> {
                 .truncated_text(32)
                 .to_string()
         };
-        let p2 = stock_str::read_rcpt_mail_body(context, p1).await;
+        let p2 = stock_str::read_rcpt_mail_body(context, &p1).await;
         let message_text = format!("{}\r\n", format_flowed(&p2));
         message = message.child(
             PartBuilder::new()
@@ -1285,19 +1287,20 @@ impl<'a> MimeFactory<'a> {
         let extension_fields = if additional_msg_ids.is_empty() {
             "".to_string()
         } else {
-            "Additional-Message-IDs: ".to_string()
-                + &additional_msg_ids
+            format!(
+                "Additional-Message-IDs: {}\r\n",
+                additional_msg_ids
                     .iter()
                     .map(|mid| render_rfc724_mid(mid))
                     .collect::<Vec<String>>()
                     .join(" ")
-                + "\r\n"
+            )
         };
 
         message = message.child(
             PartBuilder::new()
                 .content_type(&"message/disposition-notification".parse().unwrap())
-                .body(message_text2 + &extension_fields)
+                .body(message_text2 + extension_fields.as_str())
                 .build(),
         );
 
@@ -1337,14 +1340,16 @@ async fn build_body_file(
     // etc.
     let filename_to_send: String = match msg.viewtype {
         Viewtype::Voice => chrono::Utc
-            .timestamp(msg.timestamp_sort, 0)
+            .timestamp_opt(msg.timestamp_sort, 0)
+            .unwrap()
             .format(&format!("voice-message_%Y-%m-%d_%H-%M-%S.{}", &suffix))
             .to_string(),
         Viewtype::Image | Viewtype::Gif => format!(
             "{}.{}",
             if base_name.is_empty() {
                 chrono::Utc
-                    .timestamp(msg.timestamp_sort, 0)
+                    .timestamp_opt(msg.timestamp_sort, 0)
+                    .unwrap()
                     .format("image_%Y-%m-%d_%H-%M-%S")
                     .to_string()
             } else {
@@ -1355,7 +1360,8 @@ async fn build_body_file(
         Viewtype::Video => format!(
             "video_{}.{}",
             chrono::Utc
-                .timestamp(msg.timestamp_sort, 0)
+                .timestamp_opt(msg.timestamp_sort, 0)
+                .unwrap()
                 .format("%Y-%m-%d_%H-%M-%S"),
             &suffix
         ),

src/mimeparser.rs

@@ -21,7 +21,6 @@ use crate::events::EventType;
 use crate::format_flowed::unformat_flowed;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::key::Fingerprint;
-use crate::location;
 use crate::message::{self, Viewtype};
 use crate::param::{Param, Params};
 use crate::peerstate::Peerstate;
@@ -29,6 +28,7 @@ use crate::simplify::{simplify, SimplifiedText};
 use crate::stock_str;
 use crate::sync::SyncItems;
 use crate::tools::{get_filemeta, parse_receive_headers, truncate_by_lines};
+use crate::{location, tools};
 
 /// A parsed MIME message.
 ///
@@ -46,7 +46,7 @@ pub struct MimeMessage {
 
     /// Addresses are normalized and lowercased:
     pub recipients: Vec<SingleInfo>,
-    pub from: Vec<SingleInfo>,
+    pub from: SingleInfo,
     /// Whether the From address was repeated in the signed part
     /// (and we know that the signer intended to send from this address)
     pub from_is_signed: bool,
@@ -166,7 +166,7 @@ impl MimeMessage {
     ///
     /// If `partial` is set, it contains the full message size in bytes
     /// and `body` contains the header only.
-    pub async fn from_bytes_with_partial(
+    pub(crate) async fn from_bytes_with_partial(
         context: &Context,
         body: &[u8],
         partial: Option<u32>,
@@ -216,11 +216,21 @@ impl MimeMessage {
         headers.remove("secure-join-fingerprint");
         headers.remove("chat-verified");
 
+        let is_thunderbird = headers
+            .get("user-agent")
+            .map_or(false, |user_agent| user_agent.contains("Thunderbird"));
+        if is_thunderbird {
+            info!(context, "Detected Thunderbird");
+        }
+
+        let from = from.context("No from in message")?;
+        let mut decryption_info =
+            prepare_decryption(context, &mail, &from.addr, message_time, is_thunderbird).await?;
+
         // Memory location for a possible decrypted message.
         let mut mail_raw = Vec::new();
         let mut gossiped_addr = Default::default();
         let mut from_is_signed = false;
-        let mut decryption_info = prepare_decryption(context, &mail, &from, message_time).await?;
         hop_info += "\n\n";
         hop_info += &decryption_info.dkim_results.to_string();
 
@@ -255,7 +265,7 @@ impl MimeMessage {
 
                     // Signature was checked for original From, so we
                     // do not allow overriding it.
-                    let mut signed_from = Vec::new();
+                    let mut signed_from = None;
 
                     // We do not want to allow unencrypted subject in encrypted emails because the user might falsely think that the subject is safe.
                     // See <https://github.com/deltachat/deltachat-core-rust/issues/1790>.
@@ -270,23 +280,21 @@ impl MimeMessage {
                         &mut chat_disposition_notification_to,
                         &decrypted_mail.headers,
                     );
-                    if let Some(signed_from) = signed_from.first() {
-                        if let Some(from) = from.first() {
-                            if addr_cmp(&signed_from.addr, &from.addr) {
-                                from_is_signed = true;
-                            } else {
-                                // There is a From: header in the encrypted &
-                                // signed part, but it doesn't match the outer one.
-                                // This _might_ be because the sender's mail server
-                                // replaced the sending address, e.g. in a mailing list.
-                                // Or it's because someone is doing some replay attack
-                                // - OTOH, I can't come up with an attack scenario
-                                // where this would be useful.
-                                warn!(
-                                    context,
-                                    "From header in signed part does't match the outer one"
-                                );
-                            }
+                    if let Some(signed_from) = signed_from {
+                        if addr_cmp(&signed_from.addr, &from.addr) {
+                            from_is_signed = true;
+                        } else {
+                            // There is a From: header in the encrypted &
+                            // signed part, but it doesn't match the outer one.
+                            // This _might_ be because the sender's mail server
+                            // replaced the sending address, e.g. in a mailing list.
+                            // Or it's because someone is doing some replay attack
+                            // - OTOH, I can't come up with an attack scenario
+                            // where this would be useful.
+                            warn!(
+                                context,
+                                "From header in signed part does't match the outer one"
+                            );
                         }
                     }
 
@@ -302,7 +310,7 @@ impl MimeMessage {
                         // && decryption_info.dkim_results.allow_keychange
                         {
                             peerstate.degrade_encryption(message_time);
-                            peerstate.save_to_db(&context.sql, false).await?;
+                            peerstate.save_to_db(&context.sql).await?;
                         }
                     }
                     (Ok(mail), HashSet::new(), false)
@@ -582,21 +590,18 @@ impl MimeMessage {
         // See if an MDN is requested from the other side
         if !self.decrypting_failed && !self.parts.is_empty() {
             if let Some(ref dn_to) = self.chat_disposition_notification_to {
-                if let Some(from) = self.from.get(0) {
-                    // Check that the message is not outgoing.
-                    if !context.is_self_addr(&from.addr).await? {
-                        if from.addr.to_lowercase() == dn_to.addr.to_lowercase() {
-                            if let Some(part) = self.parts.last_mut() {
-                                part.param.set_int(Param::WantsMdn, 1);
-                            }
-                        } else {
-                            warn!(
-                                context,
-                                "{} requested a read receipt to {}, ignoring",
-                                from.addr,
-                                dn_to.addr
-                            );
+                // Check that the message is not outgoing.
+                let from = &self.from.addr;
+                if !context.is_self_addr(from).await? {
+                    if from.to_lowercase() == dn_to.addr.to_lowercase() {
+                        if let Some(part) = self.parts.last_mut() {
+                            part.param.set_int(Param::WantsMdn, 1);
                         }
+                    } else {
+                        warn!(
+                            context,
+                            "{} requested a read receipt to {}, ignoring", from, dn_to.addr
+                        );
                     }
                 }
             }
@@ -1226,7 +1231,7 @@ impl MimeMessage {
         context: &Context,
         headers: &mut HashMap<String, String>,
         recipients: &mut Vec<SingleInfo>,
-        from: &mut Vec<SingleInfo>,
+        from: &mut Option<SingleInfo>,
         list_post: &mut Option<String>,
         chat_disposition_notification_to: &mut Option<SingleInfo>,
         fields: &[mailparse::MailHeader<'_>],
@@ -1255,7 +1260,7 @@ impl MimeMessage {
             *recipients = recipients_new;
         }
         let from_new = get_from(fields);
-        if !from_new.is_empty() {
+        if from_new.is_some() {
             *from = from_new;
         }
         let list_post_new = get_list_post(fields);
@@ -1581,11 +1586,11 @@ async fn update_gossip_peerstates(
         let peerstate;
         if let Some(mut p) = Peerstate::from_addr(context, &header.addr).await? {
             p.apply_gossip(&header, message_time);
-            p.save_to_db(&context.sql, false).await?;
+            p.save_to_db(&context.sql).await?;
             peerstate = p;
         } else {
             let p = Peerstate::from_gossip(&header, message_time);
-            p.save_to_db(&context.sql, true).await?;
+            p.save_to_db(&context.sql).await?;
             peerstate = p;
         };
         peerstate
@@ -1800,8 +1805,9 @@ pub(crate) fn get_recipients(headers: &[MailHeader]) -> Vec<SingleInfo> {
 }
 
 /// Returned addresses are normalized and lowercased.
-pub(crate) fn get_from(headers: &[MailHeader]) -> Vec<SingleInfo> {
-    get_all_addresses_from_header(headers, |header_key| header_key == "from")
+pub(crate) fn get_from(headers: &[MailHeader]) -> Option<SingleInfo> {
+    let all = get_all_addresses_from_header(headers, |header_key| header_key == "from");
+    tools::single_value(all)
 }
 
 /// Returned addresses are normalized and lowercased.
@@ -1877,35 +1883,35 @@ mod tests {
         let mimemsg = MimeMessage::from_bytes(&ctx, b"From: g@c.de\n\nhi")
             .await
             .unwrap();
-        let contact = mimemsg.from.first().unwrap();
+        let contact = mimemsg.from;
         assert_eq!(contact.addr, "g@c.de");
         assert_eq!(contact.display_name, None);
 
         let mimemsg = MimeMessage::from_bytes(&ctx, b"From:   g@c.de  \n\nhi")
             .await
             .unwrap();
-        let contact = mimemsg.from.first().unwrap();
+        let contact = mimemsg.from;
         assert_eq!(contact.addr, "g@c.de");
         assert_eq!(contact.display_name, None);
 
         let mimemsg = MimeMessage::from_bytes(&ctx, b"From: <g@c.de>\n\nhi")
             .await
             .unwrap();
-        let contact = mimemsg.from.first().unwrap();
+        let contact = mimemsg.from;
         assert_eq!(contact.addr, "g@c.de");
         assert_eq!(contact.display_name, None);
 
         let mimemsg = MimeMessage::from_bytes(&ctx, b"From: Goetz C <g@c.de>\n\nhi")
             .await
             .unwrap();
-        let contact = mimemsg.from.first().unwrap();
+        let contact = mimemsg.from;
         assert_eq!(contact.addr, "g@c.de");
         assert_eq!(contact.display_name, Some("Goetz C".to_string()));
 
         let mimemsg = MimeMessage::from_bytes(&ctx, b"From: \"Goetz C\" <g@c.de>\n\nhi")
             .await
             .unwrap();
-        let contact = mimemsg.from.first().unwrap();
+        let contact = mimemsg.from;
         assert_eq!(contact.addr, "g@c.de");
         assert_eq!(contact.display_name, Some("Goetz C".to_string()));
 
@@ -1913,7 +1919,7 @@ mod tests {
             MimeMessage::from_bytes(&ctx, b"From: =?utf-8?q?G=C3=B6tz?= C <g@c.de>\n\nhi")
                 .await
                 .unwrap();
-        let contact = mimemsg.from.first().unwrap();
+        let contact = mimemsg.from;
         assert_eq!(contact.addr, "g@c.de");
         assert_eq!(contact.display_name, Some("Götz C".to_string()));
 
@@ -1923,7 +1929,7 @@ mod tests {
             MimeMessage::from_bytes(&ctx, b"From: \"=?utf-8?q?G=C3=B6tz?= C\" <g@c.de>\n\nhi")
                 .await
                 .unwrap();
-        let contact = mimemsg.from.first().unwrap();
+        let contact = mimemsg.from;
         assert_eq!(contact.addr, "g@c.de");
         assert_eq!(contact.display_name, Some("Götz C".to_string()));
     }
@@ -2155,14 +2161,9 @@ mod tests {
                     test1\n\
                     ";
 
-        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes_with_partial(&context.ctx, &raw[..], None).await;
 
-        let of = &mimeparser.from[0];
-        assert_eq!(of.addr, "hello@one.org");
-
-        assert!(mimeparser.chat_disposition_notification_to.is_none());
+        assert!(mimeparser.is_err());
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -2201,7 +2202,7 @@ mod tests {
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_mimeparser_with_context() {
         let context = TestContext::new().await;
-        let raw = b"From: hello\n\
+        let raw = b"From: hello@example.org\n\
                     Content-Type: multipart/mixed; boundary=\"==break==\";\n\
                     Subject: outer-subject\n\
                     Secure-Join-Group: no\n\

src/peerstate.rs

@@ -4,7 +4,7 @@ use std::collections::HashSet;
 use std::fmt;
 
 use crate::aheader::{Aheader, EncryptPreference};
-use crate::chat::{self, is_contact_in_chat, Chat};
+use crate::chat::{self, Chat};
 use crate::chatlist::Chatlist;
 use crate::constants::Chattype;
 use crate::contact::{addr_cmp, Contact, Origin};
@@ -46,7 +46,6 @@ pub struct Peerstate {
     pub gossip_key_fingerprint: Option<Fingerprint>,
     pub verified_key: Option<SignedPublicKey>,
     pub verified_key_fingerprint: Option<Fingerprint>,
-    pub to_save: Option<ToSave>,
     pub fingerprint_changed: bool,
 }
 
@@ -63,7 +62,6 @@ impl PartialEq for Peerstate {
             && self.gossip_key_fingerprint == other.gossip_key_fingerprint
             && self.verified_key == other.verified_key
             && self.verified_key_fingerprint == other.verified_key_fingerprint
-            && self.to_save == other.to_save
             && self.fingerprint_changed == other.fingerprint_changed
     }
 }
@@ -84,19 +82,11 @@ impl fmt::Debug for Peerstate {
             .field("gossip_key_fingerprint", &self.gossip_key_fingerprint)
             .field("verified_key", &self.verified_key)
             .field("verified_key_fingerprint", &self.verified_key_fingerprint)
-            .field("to_save", &self.to_save)
             .field("fingerprint_changed", &self.fingerprint_changed)
             .finish()
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
-#[repr(u8)]
-pub enum ToSave {
-    Timestamps = 0x01,
-    All = 0x02,
-}
-
 impl Peerstate {
     pub fn from_header(header: &Aheader, message_time: i64) -> Self {
         Peerstate {
@@ -111,7 +101,6 @@ impl Peerstate {
             gossip_timestamp: 0,
             verified_key: None,
             verified_key_fingerprint: None,
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         }
     }
@@ -137,7 +126,6 @@ impl Peerstate {
             gossip_timestamp: message_time,
             verified_key: None,
             verified_key_fingerprint: None,
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         }
     }
@@ -229,7 +217,6 @@ impl Peerstate {
                         .map(|s| s.parse::<Fingerprint>())
                         .transpose()
                         .unwrap_or_default(),
-                    to_save: None,
                     fingerprint_changed: false,
                 };
 
@@ -248,14 +235,10 @@ impl Peerstate {
             let old_public_fingerprint = self.public_key_fingerprint.take();
             self.public_key_fingerprint = Some(public_key.fingerprint());
 
-            if old_public_fingerprint.is_none()
-                || self.public_key_fingerprint.is_none()
-                || old_public_fingerprint != self.public_key_fingerprint
+            if old_public_fingerprint.is_some()
+                && old_public_fingerprint != self.public_key_fingerprint
             {
-                self.to_save = Some(ToSave::All);
-                if old_public_fingerprint.is_some() {
-                    self.fingerprint_changed = true;
-                }
+                self.fingerprint_changed = true;
             }
         }
 
@@ -267,8 +250,6 @@ impl Peerstate {
                 || self.gossip_key_fingerprint.is_none()
                 || old_gossip_fingerprint != self.gossip_key_fingerprint
             {
-                self.to_save = Some(ToSave::All);
-
                 // Warn about gossip key change only if there is no public key obtained from
                 // Autocrypt header, which overrides gossip key.
                 if old_gossip_fingerprint.is_some() && self.public_key_fingerprint.is_none() {
@@ -281,7 +262,6 @@ impl Peerstate {
     pub fn degrade_encryption(&mut self, message_time: i64) {
         self.prefer_encrypt = EncryptPreference::Reset;
         self.last_seen = message_time;
-        self.to_save = Some(ToSave::All);
     }
 
     pub fn apply_header(&mut self, header: &Aheader, message_time: i64) {
@@ -292,19 +272,16 @@ impl Peerstate {
         if message_time > self.last_seen {
             self.last_seen = message_time;
             self.last_seen_autocrypt = message_time;
-            self.to_save = Some(ToSave::Timestamps);
             if (header.prefer_encrypt == EncryptPreference::Mutual
                 || header.prefer_encrypt == EncryptPreference::NoPreference)
                 && header.prefer_encrypt != self.prefer_encrypt
             {
                 self.prefer_encrypt = header.prefer_encrypt;
-                self.to_save = Some(ToSave::All)
             }
 
             if self.public_key.as_ref() != Some(&header.public_key) {
                 self.public_key = Some(header.public_key.clone());
                 self.recalc_fingerprint();
-                self.to_save = Some(ToSave::All);
             }
         }
     }
@@ -316,11 +293,9 @@ impl Peerstate {
 
         if message_time > self.gossip_timestamp {
             self.gossip_timestamp = message_time;
-            self.to_save = Some(ToSave::Timestamps);
             if self.gossip_key.as_ref() != Some(&gossip_header.public_key) {
                 self.gossip_key = Some(gossip_header.public_key.clone());
                 self.recalc_fingerprint();
-                self.to_save = Some(ToSave::All)
             }
 
             // This is non-standard.
@@ -339,7 +314,6 @@ impl Peerstate {
                 && gossip_header.prefer_encrypt == EncryptPreference::Mutual
             {
                 self.prefer_encrypt = EncryptPreference::Mutual;
-                self.to_save = Some(ToSave::All);
             }
         };
     }
@@ -395,7 +369,6 @@ impl Peerstate {
                     if self.public_key_fingerprint.is_some()
                         && self.public_key_fingerprint.as_ref().unwrap() == fingerprint
                     {
-                        self.to_save = Some(ToSave::All);
                         self.verified_key = self.public_key.clone();
                         self.verified_key_fingerprint = self.public_key_fingerprint.clone();
                         true
@@ -407,7 +380,6 @@ impl Peerstate {
                     if self.gossip_key_fingerprint.is_some()
                         && self.gossip_key_fingerprint.as_ref().unwrap() == fingerprint
                     {
-                        self.to_save = Some(ToSave::All);
                         self.verified_key = self.gossip_key.clone();
                         self.verified_key_fingerprint = self.gossip_key_fingerprint.clone();
                         true
@@ -421,66 +393,48 @@ impl Peerstate {
         }
     }
 
-    pub async fn save_to_db(&self, sql: &Sql, create: bool) -> Result<()> {
-        if self.to_save == Some(ToSave::All) || create {
-            sql.execute(
-                if create {
-                    "INSERT INTO acpeerstates ( \
-                         last_seen, \
-                         last_seen_autocrypt, \
-                         prefer_encrypted, \
-                         public_key, \
-                         gossip_timestamp, \
-                         gossip_key, \
-                         public_key_fingerprint, \
-                         gossip_key_fingerprint, \
-                         verified_key, \
-                         verified_key_fingerprint, \
-                         addr \
-                ) VALUES(?,?,?,?,?,?,?,?,?,?,?)"
-                } else {
-                    "UPDATE acpeerstates \
-                 SET last_seen=?, \
-                 last_seen_autocrypt=?, \
-                 prefer_encrypted=?, \
-                 public_key=?, \
-                 gossip_timestamp=?, \
-                 gossip_key=?, \
-                 public_key_fingerprint=?, \
-                 gossip_key_fingerprint=?, \
-                 verified_key=?, \
-                 verified_key_fingerprint=? \
-                 WHERE addr=?"
-                },
-                paramsv![
-                    self.last_seen,
-                    self.last_seen_autocrypt,
-                    self.prefer_encrypt as i64,
-                    self.public_key.as_ref().map(|k| k.to_bytes()),
-                    self.gossip_timestamp,
-                    self.gossip_key.as_ref().map(|k| k.to_bytes()),
-                    self.public_key_fingerprint.as_ref().map(|fp| fp.hex()),
-                    self.gossip_key_fingerprint.as_ref().map(|fp| fp.hex()),
-                    self.verified_key.as_ref().map(|k| k.to_bytes()),
-                    self.verified_key_fingerprint.as_ref().map(|fp| fp.hex()),
-                    self.addr,
-                ],
-            )
-            .await?;
-        } else if self.to_save == Some(ToSave::Timestamps) {
-            sql.execute(
-                "UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? \
-                 WHERE addr=?;",
-                paramsv![
-                    self.last_seen,
-                    self.last_seen_autocrypt,
-                    self.gossip_timestamp,
-                    self.addr
-                ],
-            )
-            .await?;
-        }
-
+    pub async fn save_to_db(&self, sql: &Sql) -> Result<()> {
+        sql.execute(
+            "INSERT INTO acpeerstates (
+                last_seen,
+                last_seen_autocrypt,
+                prefer_encrypted,
+                public_key,
+                gossip_timestamp,
+                gossip_key,
+                public_key_fingerprint,
+                gossip_key_fingerprint,
+                verified_key,
+                verified_key_fingerprint,
+                addr)
+                VALUES (?,?,?,?,?,?,?,?,?,?,?)
+                ON CONFLICT (addr)
+                DO UPDATE SET
+                  last_seen = excluded.last_seen,
+                  last_seen_autocrypt = excluded.last_seen_autocrypt,
+                  prefer_encrypted = excluded.prefer_encrypted,
+                  public_key = excluded.public_key,
+                  gossip_timestamp = excluded.gossip_timestamp,
+                  gossip_key = excluded.gossip_key,
+                  public_key_fingerprint = excluded.public_key_fingerprint,
+                  gossip_key_fingerprint = excluded.gossip_key_fingerprint,
+                  verified_key = excluded.verified_key,
+                  verified_key_fingerprint = excluded.verified_key_fingerprint",
+            paramsv![
+                self.last_seen,
+                self.last_seen_autocrypt,
+                self.prefer_encrypt as i64,
+                self.public_key.as_ref().map(|k| k.to_bytes()),
+                self.gossip_timestamp,
+                self.gossip_key.as_ref().map(|k| k.to_bytes()),
+                self.public_key_fingerprint.as_ref().map(|fp| fp.hex()),
+                self.gossip_key_fingerprint.as_ref().map(|fp| fp.hex()),
+                self.verified_key.as_ref().map(|k| k.to_bytes()),
+                self.verified_key_fingerprint.as_ref().map(|fp| fp.hex()),
+                self.addr,
+            ],
+        )
+        .await?;
         Ok(())
     }
 
@@ -520,7 +474,7 @@ impl Peerstate {
         let chats = Chatlist::try_load(context, 0, None, Some(contact_id)).await?;
         let msg = match &change {
             PeerstateChange::FingerprintChange => {
-                stock_str::contact_setup_changed(context, self.addr.clone()).await
+                stock_str::contact_setup_changed(context, &self.addr).await
             }
             PeerstateChange::Aeap(new_addr) => {
                 let old_contact = Contact::load_from_db(context, contact_id).await?;
@@ -569,9 +523,7 @@ impl Peerstate {
                     let (new_contact_id, _) =
                         Contact::add_or_lookup(context, "", new_addr, Origin::IncomingUnknownFrom)
                             .await?;
-                    if !is_contact_in_chat(context, *chat_id, new_contact_id).await? {
-                        chat::add_to_chat_contacts_table(context, *chat_id, new_contact_id).await?;
-                    }
+                    chat::add_to_chat_contacts_table(context, *chat_id, &[new_contact_id]).await?;
 
                     context.emit_event(EventType::ChatModified(*chat_id));
                 }
@@ -617,10 +569,9 @@ pub async fn maybe_do_aeap_transition(
     mime_parser: &crate::mimeparser::MimeMessage,
 ) -> Result<()> {
     if let Some(peerstate) = &mut info.peerstate {
-        if let Some(from) = mime_parser.from.first() {
-            // If the from addr is different from the peerstate address we know,
-            // we may want to do an AEAP transition.
-            if !addr_cmp(&peerstate.addr, &from.addr)
+        // If the from addr is different from the peerstate address we know,
+        // we may want to do an AEAP transition.
+        if !addr_cmp(&peerstate.addr, &mime_parser.from.addr)
                 // Check if it's a chat message; we do this to avoid
                 // some accidental transitions if someone writes from multiple
                 // addresses with an MUA.
@@ -636,31 +587,24 @@ pub async fn maybe_do_aeap_transition(
                 // to the attacker's address, allowing for easier phishing.
                 && mime_parser.from_is_signed
                 && info.message_time > peerstate.last_seen
-            {
-                // Add info messages to chats with this (verified) contact
-                //
-                peerstate
-                    .handle_setup_change(
-                        context,
-                        info.message_time,
-                        PeerstateChange::Aeap(info.from.clone()),
-                    )
-                    .await?;
+        {
+            // Add info messages to chats with this (verified) contact
+            //
+            peerstate
+                .handle_setup_change(
+                    context,
+                    info.message_time,
+                    PeerstateChange::Aeap(info.from.clone()),
+                )
+                .await?;
 
-                peerstate.addr = info.from.clone();
-                let header = info.autocrypt_header.as_ref().context(
-                    "Internal error: Tried to do an AEAP transition without an autocrypt header??",
-                )?;
-                peerstate.apply_header(header, info.message_time);
-                peerstate.to_save = Some(ToSave::All);
+            peerstate.addr = info.from.clone();
+            let header = info.autocrypt_header.as_ref().context(
+                "Internal error: Tried to do an AEAP transition without an autocrypt header??",
+            )?;
+            peerstate.apply_header(header, info.message_time);
 
-                // We don't know whether a peerstate with this address already existed, or a
-                // new one should be created, so just try both create=false and create=true,
-                // and if this fails, create=true, one will succeed (this is a very cold path,
-                // so performance doesn't really matter).
-                peerstate.save_to_db(&context.sql, true).await?;
-                peerstate.save_to_db(&context.sql, false).await?;
-            }
+            peerstate.save_to_db(&context.sql).await?;
         }
     }
 
@@ -712,7 +656,7 @@ mod tests {
 
         let pub_key = alice_keypair().public;
 
-        let mut peerstate = Peerstate {
+        let peerstate = Peerstate {
             addr: addr.into(),
             last_seen: 10,
             last_seen_autocrypt: 11,
@@ -724,12 +668,11 @@ mod tests {
             gossip_key_fingerprint: Some(pub_key.fingerprint()),
             verified_key: Some(pub_key.clone()),
             verified_key_fingerprint: Some(pub_key.fingerprint()),
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         };
 
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql).await.is_ok(),
             "failed to save to db"
         );
 
@@ -738,8 +681,6 @@ mod tests {
             .expect("failed to load peerstate from db")
             .expect("no peerstate found in the database");
 
-        // clear to_save, as that is not persissted
-        peerstate.to_save = None;
         assert_eq!(peerstate, peerstate_new);
         let peerstate_new2 = Peerstate::from_fingerprint(&ctx.ctx, &pub_key.fingerprint())
             .await
@@ -766,16 +707,15 @@ mod tests {
             gossip_key_fingerprint: None,
             verified_key: None,
             verified_key_fingerprint: None,
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         };
 
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql).await.is_ok(),
             "failed to save"
         );
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql).await.is_ok(),
             "double-call with create failed"
         );
     }
@@ -787,7 +727,7 @@ mod tests {
 
         let pub_key = alice_keypair().public;
 
-        let mut peerstate = Peerstate {
+        let peerstate = Peerstate {
             addr: addr.into(),
             last_seen: 10,
             last_seen_autocrypt: 11,
@@ -799,12 +739,11 @@ mod tests {
             gossip_key_fingerprint: None,
             verified_key: None,
             verified_key_fingerprint: None,
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         };
 
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql).await.is_ok(),
             "failed to save"
         );
 
@@ -812,8 +751,6 @@ mod tests {
             .await
             .expect("failed to load peerstate from db");
 
-        // clear to_save, as that is not persissted
-        peerstate.to_save = None;
         assert_eq!(Some(peerstate), peerstate_new);
     }
 
@@ -864,7 +801,6 @@ mod tests {
             gossip_key_fingerprint: None,
             verified_key: None,
             verified_key_fingerprint: None,
-            to_save: None,
             fingerprint_changed: false,
         };
         assert_eq!(peerstate.prefer_encrypt, EncryptPreference::NoPreference);

src/plaintext.rs

@@ -67,7 +67,7 @@ impl PlainText {
                 // and is only there to allow > at the beginning of a line that is no quote.
                 line = line.strip_prefix(' ').unwrap_or(&line).to_string();
                 if is_quote {
-                    line = "<em>".to_owned() + &line + "</em>";
+                    line = format!("<em>{}</em>", line);
                 }
 
                 // a trailing space indicates that the line can be merged with the next one;
@@ -83,7 +83,7 @@ impl PlainText {
             } else {
                 // normal, fixed text
                 if is_quote {
-                    line = "<em>".to_owned() + &line + "</em>";
+                    line = format!("<em>{}</em>", &line);
                 }
                 line += "<br/>\n";
             }

src/provider.rs

@@ -154,7 +154,7 @@ pub async fn get_provider_by_mx(context: &Context, domain: &str) -> Option<&'sta
                 }
 
                 let provider_fqdn = provider_domain.to_string() + ".";
-                let provider_fqdn_dot = ".".to_string() + &provider_fqdn;
+                let provider_fqdn_dot = format!(".{}", provider_fqdn);
 
                 for mx_domain in mx_domains.iter() {
                     let mx_domain = mx_domain.exchange().to_lowercase().to_utf8();
@@ -184,7 +184,9 @@ pub fn get_provider_by_id(id: &str) -> Option<&'static Provider> {
 
 // returns update timestamp in seconds, UTC, compatible for comparison with time() and database times
 pub fn get_provider_update_timestamp() -> i64 {
-    NaiveDateTime::new(*PROVIDER_UPDATED, NaiveTime::from_hms(0, 0, 0)).timestamp_millis() / 1_000
+    NaiveDateTime::new(*PROVIDER_UPDATED, NaiveTime::from_hms_opt(0, 0, 0).unwrap())
+        .timestamp_millis()
+        / 1_000
 }
 
 #[cfg(test)]
@@ -260,8 +262,8 @@ mod tests {
     #[test]
     fn test_get_provider_update_timestamp() {
         let timestamp_past = NaiveDateTime::new(
-            NaiveDate::from_ymd(2020, 9, 9),
-            NaiveTime::from_hms(0, 0, 0),
+            NaiveDate::from_ymd_opt(2020, 9, 9).unwrap(),
+            NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
         )
         .timestamp_millis()
             / 1_000;

src/provider/data.rs

@@ -1891,4 +1891,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, 7, 5));
+    Lazy::new(|| chrono::NaiveDate::from_ymd_opt(2022, 7, 5).unwrap());

src/qr.rs

@@ -32,6 +32,7 @@ const VCARD_SCHEME: &str = "BEGIN:VCARD";
 const SMTP_SCHEME: &str = "SMTP:";
 const HTTP_SCHEME: &str = "http://";
 const HTTPS_SCHEME: &str = "https://";
+pub const DCBACKUP_SCHEME: &str = "DCBACKUP:";
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Qr {
@@ -61,6 +62,9 @@ pub enum Qr {
     Account {
         domain: String,
     },
+    Backup {
+        ticket: iroh_share::Ticket,
+    },
     WebrtcInstance {
         domain: String,
         instance_pattern: String,
@@ -127,6 +131,8 @@ pub async fn check_qr(context: &Context, qr: &str) -> Result<Qr> {
         decode_account(qr)?
     } else if starts_with_ignore_case(qr, DCLOGIN_SCHEME) {
         dclogin_scheme::decode_login(qr)?
+    } else if starts_with_ignore_case(qr, DCBACKUP_SCHEME) {
+        decode_backup(qr)?
     } else if starts_with_ignore_case(qr, DCWEBRTC_SCHEME) {
         decode_webrtc_instance(context, qr)?
     } else if qr.starts_with(MAILTO_SCHEME) {
@@ -332,6 +338,18 @@ fn decode_account(qr: &str) -> Result<Qr> {
     }
 }
 
+/// scheme: `DCBACKUP:<multibase + bincode encode ticket>`
+fn decode_backup(qr: &str) -> Result<Qr> {
+    let payload = qr
+        .get(DCBACKUP_SCHEME.len()..)
+        .context("invalid DCBACKUP payload")?;
+
+    let (_, ticket_bytes) = multibase::decode(payload)?;
+    let ticket = iroh_share::Ticket::from_bytes(&ticket_bytes)?;
+
+    Ok(Qr::Backup { ticket })
+}
+
 /// scheme: `DCWEBRTC:https://meet.jit.si/$ROOM`
 fn decode_webrtc_instance(_context: &Context, qr: &str) -> Result<Qr> {
     let payload = qr
@@ -516,7 +534,7 @@ async fn decode_mailto(context: &Context, qr: &str) -> Result<Qr> {
         if subject.is_empty() {
             body.to_string()
         } else {
-            subject + "\n" + body
+            subject + "\n" + *body
         }
     } else {
         subject
@@ -641,7 +659,6 @@ mod tests {
     use crate::aheader::EncryptPreference;
     use crate::chat::{create_group_chat, ProtectionStatus};
     use crate::key::DcKey;
-    use crate::peerstate::ToSave;
     use crate::securejoin::get_securejoin_qr;
     use crate::test_utils::{alice_keypair, TestContext};
     use anyhow::Result;
@@ -894,11 +911,10 @@ mod tests {
             gossip_key_fingerprint: None,
             verified_key: None,
             verified_key_fingerprint: None,
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         };
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql).await.is_ok(),
             "failed to save peerstate"
         );
 

src/qr_code_generator.rs

@@ -8,6 +8,7 @@ use crate::{
     config::Config,
     contact::{Contact, ContactId},
     context::Context,
+    qr::DCBACKUP_SCHEME,
     securejoin, stock_str,
 };
 
@@ -262,6 +263,93 @@ fn inner_generate_secure_join_qr_code(
     Ok(svg)
 }
 
+pub fn generate_backup_qr_code(ticket: &iroh_share::Ticket) -> Result<String> {
+    let ticket_bytes = ticket.as_bytes();
+    let ticket_str = multibase::encode(multibase::Base::Base64, &ticket_bytes);
+    let ticket_str = format!("{}{}", DCBACKUP_SCHEME, ticket_str);
+    // config
+    let width = 515.0;
+    let height = 630.0;
+    let qr_code_size = 400.0;
+    let qr_translate_up = 40.0;
+    let card_roundness = 40.0;
+    let card_border_size = 2.0;
+
+    let qr = QrCode::encode_text(&ticket_str, QrCodeEcc::Medium)?;
+    let mut svg = String::with_capacity(28000);
+    let mut w = tagger::new(&mut svg);
+
+    w.elem("svg", |d| {
+        d.attr("xmlns", "http://www.w3.org/2000/svg")?;
+        d.attr("viewBox", format_args!("0 0 {} {}", width, height))?;
+        Ok(())
+    })?
+    .build(|w| {
+        // White Background apears like a card
+        w.single("rect", |d| {
+            d.attr("x", card_border_size)?;
+            d.attr("y", card_border_size)?;
+            d.attr("rx", card_roundness)?;
+            d.attr("stroke", "#c6c6c6")?;
+            d.attr("stroke-width", card_border_size)?;
+            d.attr("width", width - (card_border_size * 2.0))?;
+            d.attr("height", height - (card_border_size * 2.0))?;
+            d.attr("style", "fill:#f2f2f2")?;
+            Ok(())
+        })?;
+        // Qrcode
+        w.elem("g", |d| {
+            d.attr(
+                "transform",
+                format!(
+                    "translate({},{})",
+                    (width - qr_code_size) / 2.0,
+                    ((height - qr_code_size) / 2.0) - qr_translate_up
+                ),
+            )
+            // If the qr code should be in the wrong place,
+            // we could also translate and scale the points in the path already,
+            // but that would make the resulting svg way bigger in size and might bring up rounding issues,
+            // so better avoid doing it manually if possible
+        })?
+        .build(|w| {
+            w.single("path", |d| {
+                let mut path_data = String::with_capacity(0);
+                let scale = qr_code_size / qr.size() as f32;
+
+                for y in 0..qr.size() {
+                    for x in 0..qr.size() {
+                        if qr.get_module(x, y) {
+                            path_data += &format!("M{},{}h1v1h-1z", x, y);
+                        }
+                    }
+                }
+
+                d.attr("style", "fill:#000000")?;
+                d.attr("d", path_data)?;
+                d.attr("transform", format!("scale({})", scale))
+            })
+        })?;
+
+        // Footer logo
+        const FOOTER_HEIGHT: f32 = 35.0;
+        const FOOTER_WIDTH: f32 = 198.0;
+        w.elem("g", |d| {
+            d.attr(
+                "transform",
+                format!(
+                    "translate({},{})",
+                    (width - FOOTER_WIDTH) / 2.0,
+                    height - FOOTER_HEIGHT
+                ),
+            )
+        })?
+        .build(|w| w.put_raw(include_str!("../assets/qrcode_logo_footer.svg")))
+    })?;
+
+    Ok(svg)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/receive_imf.rs

@@ -13,7 +13,6 @@ use regex::Regex;
 use crate::chat::{self, Chat, ChatId, ChatIdBlocked, ProtectionStatus};
 use crate::config::Config;
 use crate::constants::{Blocked, Chattype, ShowEmails, DC_CHAT_ID_TRASH};
-use crate::contact;
 use crate::contact::{
     may_be_valid_addr, normalize_name, Contact, ContactId, Origin, VerifiedStatus,
 };
@@ -22,14 +21,14 @@ use crate::download::DownloadState;
 use crate::ephemeral::{stock_ephemeral_timer_changed, Timer as EphemeralTimer};
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
-use crate::imap::markseen_on_imap_table;
+use crate::imap::{markseen_on_imap_table, GENERATED_PREFIX};
 use crate::location;
 use crate::log::LogExt;
 use crate::message::{
     self, rfc724_mid_exists, Message, MessageState, MessengerMessage, MsgId, Viewtype,
 };
 use crate::mimeparser::{
-    parse_message_id, parse_message_ids, AvatarAction, MailinglistType, MimeMessage, SystemMessage,
+    parse_message_ids, AvatarAction, MailinglistType, MimeMessage, SystemMessage,
 };
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateKeyType, PeerstateVerifiedStatus};
@@ -37,7 +36,8 @@ use crate::reaction::{set_msg_reaction, Reaction};
 use crate::securejoin::{self, handle_securejoin_handshake, observe_securejoin_on_other_device};
 use crate::sql;
 use crate::stock_str;
-use crate::tools::{create_id, extract_grpid_from_rfc724_mid, smeared_time};
+use crate::tools::{extract_grpid_from_rfc724_mid, smeared_time};
+use crate::{contact, imap};
 
 /// This is the struct that is returned after receiving one email (aka MIME message).
 ///
@@ -66,25 +66,19 @@ pub async fn receive_imf(
     seen: bool,
 ) -> Result<Option<ReceivedMsg>> {
     let mail = parse_mail(imf_raw).context("can't parse mail")?;
-    let rfc724_mid = mail
-        .headers
-        .get_header_value(HeaderDef::MessageId)
-        .and_then(|msgid| parse_message_id(&msgid).ok())
-        .unwrap_or_else(create_id);
+    let rfc724_mid = imap::prefetch_get_or_create_message_id(&mail.headers);
     receive_imf_inner(context, &rfc724_mid, imf_raw, seen, None, false).await
 }
 
 /// Receive a message and add it to the database.
 ///
-/// Returns an error on recoverable errors, e.g. database errors. In this case,
-/// message parsing should be retried later.
+/// Returns an error on database failure or if the message is broken,
+/// e.g. has nonstandard MIME structure.
 ///
-/// If message itself is wrong, logs
-/// the error and returns success:
-/// - If possible, creates a database entry to prevent the message from being
-///   downloaded again, sets `chat_id=DC_CHAT_ID_TRASH` and returns `Ok(Some(…))`
-/// - If the message is so wrong that we didn't even create a database entry,
-///   returns `Ok(None)`
+/// If possible, creates a database entry to prevent the message from being
+/// downloaded again, sets `chat_id=DC_CHAT_ID_TRASH` and returns `Ok(Some(…))`.
+/// If the message is so wrong that we didn't even create a database entry,
+/// returns `Ok(None)`.
 ///
 /// If `is_partial_download` is set, it contains the full message size in bytes.
 /// Do not confuse that with `replace_partial_download` that will be set when the full message is loaded later.
@@ -107,7 +101,28 @@ pub(crate) async fn receive_imf_inner(
         match MimeMessage::from_bytes_with_partial(context, imf_raw, is_partial_download).await {
             Err(err) => {
                 warn!(context, "receive_imf: can't parse MIME: {}", err);
-                return Ok(None);
+                let msg_ids;
+                if !rfc724_mid.starts_with(GENERATED_PREFIX) {
+                    let row_id = context
+                        .sql
+                        .execute(
+                            "INSERT INTO msgs(rfc724_mid, chat_id) VALUES (?,?)",
+                            paramsv![rfc724_mid, DC_CHAT_ID_TRASH],
+                        )
+                        .await?;
+                    msg_ids = vec![MsgId::new(u32::try_from(row_id)?)];
+                } else {
+                    return Ok(None);
+                    // We don't have an rfc724_mid, there's no point in adding a trash entry
+                }
+
+                return Ok(Some(ReceivedMsg {
+                    chat_id: DC_CHAT_ID_TRASH,
+                    state: MessageState::Undefined,
+                    sort_timestamp: 0,
+                    msg_ids,
+                    needs_delete_job: false,
+                }));
             }
             Ok(mime_parser) => mime_parser,
         };
@@ -141,7 +156,6 @@ pub(crate) async fn receive_imf_inner(
             None
         };
 
-    // the function returns the number of created messages in the database
     let prevent_rename =
         mime_parser.is_mailinglist_message() || mime_parser.get_header(HeaderDef::Sender).is_some();
 
@@ -168,7 +182,6 @@ pub(crate) async fn receive_imf_inner(
         } else {
             Origin::IncomingUnknownTo
         },
-        prevent_rename,
     )
     .await?;
 
@@ -353,28 +366,25 @@ pub(crate) async fn receive_imf_inner(
 /// * `prevent_rename`: passed through to `add_or_lookup_contacts_by_address_list()`
 pub async fn from_field_to_contact_id(
     context: &Context,
-    from_address_list: &[SingleInfo],
+    from: &SingleInfo,
     prevent_rename: bool,
 ) -> Result<(ContactId, bool, Origin)> {
-    let from_ids = add_or_lookup_contacts_by_address_list(
+    let display_name = if prevent_rename {
+        Some("")
+    } else {
+        from.display_name.as_deref()
+    };
+    let from_id = add_or_lookup_contact_by_addr(
         context,
-        from_address_list,
+        display_name,
+        &from.addr,
         Origin::IncomingUnknownFrom,
-        prevent_rename,
     )
     .await?;
 
-    if from_ids.contains(&ContactId::SELF) {
+    if from_id == ContactId::SELF {
         Ok((ContactId::SELF, false, Origin::OutgoingBcc))
-    } else if !from_ids.is_empty() {
-        if from_ids.len() > 1 {
-            warn!(
-                context,
-                "mail has more than one From address, only using first: {:?}", from_address_list
-            );
-        }
-        let from_id = from_ids.get(0).cloned().unwrap_or_default();
-
+    } else {
         let mut from_id_blocked = false;
         let mut incoming_origin = Origin::Unknown;
         if let Ok(contact) = Contact::load_from_db(context, from_id).await {
@@ -382,13 +392,6 @@ pub async fn from_field_to_contact_id(
             incoming_origin = contact.origin;
         }
         Ok((from_id, from_id_blocked, incoming_origin))
-    } else {
-        warn!(
-            context,
-            "mail has an empty From header: {:?}", from_address_list
-        );
-
-        Ok((ContactId::UNDEFINED, false, Origin::Unknown))
     }
 }
 
@@ -570,9 +573,10 @@ async fn add_parts(
                 if chat.is_protected() {
                     let s = stock_str::unknown_sender_for_chat(context).await;
                     mime_parser.repl_msg_by_error(&s);
-                } else if let Some(from) = mime_parser.from.first() {
+                } else {
                     // In non-protected chats, just mark the sender as overridden. Therefore, the UI will prepend `~`
                     // to the sender's name, indicating to the user that he/she is not part of the group.
+                    let from = &mime_parser.from;
                     let name: &str = from.display_name.as_ref().unwrap_or(&from.addr);
                     for part in mime_parser.parts.iter_mut() {
                         part.param.set(Param::OverrideSenderDisplayname, name);
@@ -637,11 +641,9 @@ async fn add_parts(
         // if contact renaming is prevented (for mailinglists and bots),
         // we use name from From:-header as override name
         if prevent_rename {
-            if let Some(from) = mime_parser.from.first() {
-                if let Some(name) = &from.display_name {
-                    for part in mime_parser.parts.iter_mut() {
-                        part.param.set(Param::OverrideSenderDisplayname, name);
-                    }
+            if let Some(name) = &mime_parser.from.display_name {
+                for part in mime_parser.parts.iter_mut() {
+                    part.param.set(Param::OverrideSenderDisplayname, name);
                 }
             }
         }
@@ -1508,7 +1510,10 @@ async fn create_or_lookup_group(
 
         let grpname = mime_parser
             .get_header(HeaderDef::ChatGroupName)
-            .context("Chat-Group-Name vanished")?;
+            .context("Chat-Group-Name vanished")?
+            // W/a for "Space added before long group names after MIME serialization/deserialization
+            // #3650" issue. DC itself never creates group names with leading/trailing whitespace.
+            .trim();
         let new_chat_id = ChatId::create_multiuser_record(
             context,
             Chattype::Group,
@@ -1525,19 +1530,13 @@ async fn create_or_lookup_group(
         chat_id_blocked = create_blocked;
 
         // Create initial member list.
-        chat::add_to_chat_contacts_table(context, new_chat_id, ContactId::SELF).await?;
-        if !from_id.is_special() && !chat::is_contact_in_chat(context, new_chat_id, from_id).await?
-        {
-            chat::add_to_chat_contacts_table(context, new_chat_id, from_id).await?;
-        }
-        for &to_id in to_ids.iter() {
-            info!(context, "adding to={:?} to chat id={}", to_id, new_chat_id);
-            if to_id != ContactId::SELF
-                && !chat::is_contact_in_chat(context, new_chat_id, to_id).await?
-            {
-                chat::add_to_chat_contacts_table(context, new_chat_id, to_id).await?;
-            }
+        let mut members = vec![ContactId::SELF];
+        if !from_id.is_special() {
+            members.push(from_id);
         }
+        members.extend(to_ids);
+        members.dedup();
+        chat::add_to_chat_contacts_table(context, new_chat_id, &members).await?;
 
         // once, we have protected-chats explained in UI, we can uncomment the following lines.
         // ("verified groups" did not add a message anyway)
@@ -1616,9 +1615,15 @@ async fn apply_group_changes(
         {
             better_msg = Some(stock_str::msg_add_member(context, &added_member, from_id).await);
             recreate_member_list = true;
-        } else if let Some(old_name) = mime_parser.get_header(HeaderDef::ChatGroupNameChanged) {
+        } else if let Some(old_name) = mime_parser
+            .get_header(HeaderDef::ChatGroupNameChanged)
+            // See create_or_lookup_group() for explanation
+            .map(|s| s.trim())
+        {
             if let Some(grpname) = mime_parser
                 .get_header(HeaderDef::ChatGroupName)
+                // See create_or_lookup_group() for explanation
+                .map(|grpname| grpname.trim())
                 .filter(|grpname| grpname.len() < 200)
             {
                 if chat_id
@@ -1687,6 +1692,7 @@ async fn apply_group_changes(
             .update_timestamp(context, Param::MemberListTimestamp, sent_timestamp)
             .await?
         {
+            let mut members_to_add = vec![];
             if removed_id.is_some()
                 || !chat::is_contact_in_chat(context, chat_id, ContactId::SELF).await?
             {
@@ -1701,26 +1707,23 @@ async fn apply_group_changes(
                     )
                     .await?;
 
-                if removed_id != Some(ContactId::SELF) {
-                    chat::add_to_chat_contacts_table(context, chat_id, ContactId::SELF).await?;
-                }
+                members_to_add.push(ContactId::SELF);
             }
-            if !from_id.is_special()
-                && from_id != ContactId::SELF
-                && !chat::is_contact_in_chat(context, chat_id, from_id).await?
-                && removed_id != Some(from_id)
-            {
-                chat::add_to_chat_contacts_table(context, chat_id, from_id).await?;
+
+            if !from_id.is_special() {
+                members_to_add.push(from_id);
             }
-            for &to_id in to_ids.iter() {
-                if to_id != ContactId::SELF
-                    && !chat::is_contact_in_chat(context, chat_id, to_id).await?
-                    && removed_id != Some(to_id)
-                {
-                    info!(context, "adding to={:?} to chat id={}", to_id, chat_id);
-                    chat::add_to_chat_contacts_table(context, chat_id, to_id).await?;
-                }
+            members_to_add.extend(to_ids);
+            if let Some(removed_id) = removed_id {
+                members_to_add.retain(|id| *id != removed_id);
             }
+            members_to_add.dedup();
+
+            info!(
+                context,
+                "adding {:?} to chat id={}", members_to_add, chat_id
+            );
+            chat::add_to_chat_contacts_table(context, chat_id, &members_to_add).await?;
             send_event_chat_modified = true;
         }
     }
@@ -1801,10 +1804,8 @@ async fn create_or_lookup_mailinglist(
     // a usable name for these lists is in the `From` header
     // and we can detect these lists by a unique `ListId`-suffix.
     if listid.ends_with(".list-id.mcsv.net") {
-        if let Some(from) = mime_parser.from.first() {
-            if let Some(display_name) = &from.display_name {
-                name = display_name.clone();
-            }
+        if let Some(display_name) = &mime_parser.from.display_name {
+            name = display_name.clone();
         }
     }
 
@@ -1824,18 +1825,15 @@ async fn create_or_lookup_mailinglist(
     //
     // this pattern is similar to mailchimp above, however,
     // with weaker conditions and does not overwrite existing names.
-    if name.is_empty() {
-        if let Some(from) = mime_parser.from.first() {
-            if from.addr.contains("noreply")
-                || from.addr.contains("no-reply")
-                || from.addr.starts_with("notifications@")
-                || from.addr.starts_with("newsletter@")
-                || listid.ends_with(".xt.local")
-            {
-                if let Some(display_name) = &from.display_name {
-                    name = display_name.clone();
-                }
-            }
+    if name.is_empty()
+        && (mime_parser.from.addr.contains("noreply")
+            || mime_parser.from.addr.contains("no-reply")
+            || mime_parser.from.addr.starts_with("notifications@")
+            || mime_parser.from.addr.starts_with("newsletter@")
+            || listid.ends_with(".xt.local"))
+    {
+        if let Some(display_name) = &mime_parser.from.display_name {
+            name = display_name.clone();
         }
     }
 
@@ -1877,7 +1875,7 @@ async fn create_or_lookup_mailinglist(
             )
         })?;
 
-        chat::add_to_chat_contacts_table(context, chat_id, ContactId::SELF).await?;
+        chat::add_to_chat_contacts_table(context, chat_id, &[ContactId::SELF]).await?;
         Ok(Some((chat_id, Blocked::Request)))
     } else {
         info!(context, "creating list forbidden by caller");
@@ -1903,7 +1901,7 @@ async fn apply_mailinglist_changes(
         let (contact_id, _) =
             Contact::add_or_lookup(context, "", list_post, Origin::Hidden).await?;
         let mut contact = Contact::load_from_db(context, contact_id).await?;
-        if contact.param.get(Param::ListId) != Some(listid) {
+        if contact.param.get(Param::ListId) != Some(listid.as_str()) {
             contact.param.set(Param::ListId, listid);
             contact.update_param(context).await?;
         }
@@ -2007,9 +2005,7 @@ async fn create_adhoc_group(
         None,
     )
     .await?;
-    for &member_id in member_ids.iter() {
-        chat::add_to_chat_contacts_table(context, new_chat_id, member_id).await?;
-    }
+    chat::add_to_chat_contacts_table(context, new_chat_id, member_ids).await?;
 
     context.emit_event(EventType::ChatModified(new_chat_id));
 
@@ -2123,7 +2119,7 @@ async fn check_verified_properties(
                             &fp,
                             PeerstateVerifiedStatus::BidirectVerified,
                         );
-                        peerstate.save_to_db(&context.sql, false).await?;
+                        peerstate.save_to_db(&context.sql).await?;
                         is_verified = true;
                     }
                 }
@@ -2233,7 +2229,6 @@ async fn add_or_lookup_contacts_by_address_list(
     context: &Context,
     address_list: &[SingleInfo],
     origin: Origin,
-    prevent_rename: bool,
 ) -> Result<Vec<ContactId>> {
     let mut contact_ids = HashSet::new();
     for info in address_list.iter() {
@@ -2241,11 +2236,7 @@ async fn add_or_lookup_contacts_by_address_list(
         if !may_be_valid_addr(addr) {
             continue;
         }
-        let display_name = if prevent_rename {
-            Some("")
-        } else {
-            info.display_name.as_deref()
-        };
+        let display_name = info.display_name.as_deref();
         contact_ids
             .insert(add_or_lookup_contact_by_addr(context, display_name, addr, origin).await?);
     }
@@ -2276,6 +2267,7 @@ mod tests {
 
     use super::*;
 
+    use crate::aheader::EncryptPreference;
     use crate::chat::get_chat_contacts;
     use crate::chat::{get_chat_msgs, ChatItem, ChatVisibility};
     use crate::chatlist::Chatlist;
@@ -2288,7 +2280,7 @@ mod tests {
     async fn test_grpid_simple() {
         let context = TestContext::new().await;
         let raw = b"Received: (Postfix, from userid 1000); Mon, 4 Dec 2006 14:51:39 +0100 (CET)\n\
-                    From: hello\n\
+                    From: hello@example.org\n\
                     Subject: outer-subject\n\
                     In-Reply-To: <lqkjwelq123@123123>\n\
                     References: <Gr.HcxyMARjyJy.9-uvzWPTLtV@nauta.cu>\n\
@@ -2303,11 +2295,25 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_grpid_from_multiple() {
+    async fn test_bad_from() {
         let context = TestContext::new().await;
         let raw = b"Received: (Postfix, from userid 1000); Mon, 4 Dec 2006 14:51:39 +0100 (CET)\n\
                     From: hello\n\
                     Subject: outer-subject\n\
+                    In-Reply-To: <lqkjwelq123@123123>\n\
+                    References: <Gr.HcxyMARjyJy.9-uvzWPTLtV@nauta.cu>\n\
+                    \n\
+                    hello\x00";
+        let mimeparser = MimeMessage::from_bytes_with_partial(&context.ctx, &raw[..], None).await;
+        assert!(mimeparser.is_err());
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_grpid_from_multiple() {
+        let context = TestContext::new().await;
+        let raw = b"Received: (Postfix, from userid 1000); Mon, 4 Dec 2006 14:51:39 +0100 (CET)\n\
+                    From: hello@example.org\n\
+                    Subject: outer-subject\n\
                     In-Reply-To: <Gr.HcxyMARjyJy.9-qweqwe@asd.net>\n\
                     References: <qweqweqwe>, <Gr.HcxyMARjyJy.9-uvzWPTLtV@nau.ca>\n\
                     \n\
@@ -2593,8 +2599,55 @@ mod tests {
         .unwrap();
 
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
-        // Check that the message was added to the database:
-        assert!(chats.get_msg_id(0).is_ok());
+        // Check that the message is not shown to the user:
+        assert!(chats.is_empty());
+
+        // Check that the message was added to the db:
+        assert!(message::rfc724_mid_exists(context, "3924@example.com")
+            .await
+            .unwrap()
+            .is_some());
+    }
+
+    /// If there is no Message-Id header, we generate a random id.
+    /// But there is no point in adding a trash entry in the database
+    /// if the email is malformed (e.g. because `From` is missing)
+    /// with this random id we just generated.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_no_message_id_header() {
+        let t = TestContext::new_alice().await;
+
+        let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
+        assert!(chats.get_msg_id(0).is_err());
+
+        let received = receive_imf(
+            &t,
+            b"Received: (Postfix, from userid 1000); Mon, 4 Dec 2006 14:51:39 +0100 (CET)\n\
+              To: bob@example.com\n\
+              Subject: foo\n\
+              Chat-Version: 1.0\n\
+              Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
+              \n\
+              hello\n",
+            false,
+        )
+        .await
+        .unwrap();
+        dbg!(&received);
+        assert!(received.is_none());
+
+        assert!(!t
+            .sql
+            .exists(
+                "SELECT COUNT(*) FROM msgs WHERE chat_id=?;",
+                paramsv![DC_CHAT_ID_TRASH],
+            )
+            .await
+            .unwrap());
+
+        let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
+        // Check that the message is not shown to the user:
+        assert!(chats.is_empty());
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -5097,13 +5150,10 @@ Reply from different address
         chat::add_to_chat_contacts_table(
             &bob,
             group_id,
-            bob.add_or_lookup_contact(&alice1).await.id,
-        )
-        .await?;
-        chat::add_to_chat_contacts_table(
-            &bob,
-            group_id,
-            Contact::create(&bob, "", "charlie@example.org").await?,
+            &[
+                bob.add_or_lookup_contact(&alice1).await.id,
+                Contact::create(&bob, "", "charlie@example.org").await?,
+            ],
         )
         .await?;
 
@@ -5184,7 +5234,7 @@ Reply from different address
         chat::add_to_chat_contacts_table(
             &bob,
             group_id,
-            bob.add_or_lookup_contact(&alice).await.id,
+            &[bob.add_or_lookup_contact(&alice).await.id],
         )
         .await?;
 
@@ -5237,4 +5287,20 @@ Reply from different address
 
         Ok(())
     }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_thunderbird_autocrypt() -> Result<()> {
+        let t = TestContext::new_bob().await;
+        t.set_config(Config::ShowEmails, Some("2")).await?;
+
+        let raw = include_bytes!("../test-data/message/thunderbird_with_autocrypt.eml");
+        receive_imf(&t, raw, false).await?;
+
+        let peerstate = Peerstate::from_addr(&t, "alice@example.org")
+            .await?
+            .unwrap();
+        assert_eq!(peerstate.prefer_encrypt, EncryptPreference::Mutual);
+
+        Ok(())
+    }
 }

src/scheduler/connectivity.rs

@@ -12,7 +12,7 @@ use crate::tools::time;
 use crate::{config::Config, scheduler::Scheduler, stock_str, tools};
 use crate::{context::Context, log::LogExt};
 use anyhow::{anyhow, Result};
-use humansize::{file_size_opts, FileSize};
+use humansize::{format_size, BINARY};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumProperty, PartialOrd, Ord)]
 pub enum Connectivity {
@@ -448,7 +448,7 @@ impl Context {
         //                                [======67%=====       ]
         // =============================================================================================
 
-        let domain = tools::EmailAddress::new(&self.get_primary_self_addr().await?)?.domain;
+        let domain = &tools::EmailAddress::new(&self.get_primary_self_addr().await?)?.domain;
         let storage_on_domain = stock_str::storage_on_domain(self, domain).await;
         ret += &format!("<h3>{}</h3><ul>", storage_on_domain);
         let quota = self.quota.read().await;
@@ -473,8 +473,8 @@ impl Context {
                             let messages = stock_str::messages(self).await;
                             let part_of_total_used = stock_str::part_of_total_used(
                                 self,
-                                resource.usage.to_string(),
-                                resource.limit.to_string(),
+                                &resource.usage.to_string(),
+                                &resource.limit.to_string(),
                             )
                             .await;
                             ret += &match &resource.name {
@@ -495,12 +495,8 @@ impl Context {
                                     // - the string is not longer than the other strings that way (minus title, plus units) -
                                     //   additional linebreaks on small displays are unlikely therefore
                                     // - most times, this is the only item anyway
-                                    let usage = (resource.usage * 1024)
-                                        .file_size(file_size_opts::BINARY)
-                                        .unwrap_or_default();
-                                    let limit = (resource.limit * 1024)
-                                        .file_size(file_size_opts::BINARY)
-                                        .unwrap_or_default();
+                                    let usage = &format_size(resource.usage * 1024, BINARY);
+                                    let limit = &format_size(resource.limit * 1024, BINARY);
                                     stock_str::part_of_total_used(self, usage, limit).await
                                 }
                             };

src/securejoin.rs

@@ -18,7 +18,7 @@ use crate::key::{DcKey, Fingerprint, SignedPublicKey};
 use crate::message::{Message, Viewtype};
 use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::param::Param;
-use crate::peerstate::{Peerstate, PeerstateKeyType, PeerstateVerifiedStatus, ToSave};
+use crate::peerstate::{Peerstate, PeerstateKeyType, PeerstateVerifiedStatus};
 use crate::qr::check_qr;
 use crate::stock_str;
 use crate::token;
@@ -640,11 +640,7 @@ async fn mark_peer_as_verified(context: &Context, fingerprint: &Fingerprint) ->
             PeerstateVerifiedStatus::BidirectVerified,
         ) {
             peerstate.prefer_encrypt = EncryptPreference::Mutual;
-            peerstate.to_save = Some(ToSave::All);
-            peerstate
-                .save_to_db(&context.sql, false)
-                .await
-                .unwrap_or_default();
+            peerstate.save_to_db(&context.sql).await.unwrap_or_default();
             return Ok(());
         }
     }
@@ -932,10 +928,9 @@ mod tests {
             gossip_key_fingerprint: Some(alice_pubkey.fingerprint()),
             verified_key: None,
             verified_key_fingerprint: None,
-            to_save: Some(ToSave::All),
             fingerprint_changed: false,
         };
-        peerstate.save_to_db(&bob.ctx.sql, true).await?;
+        peerstate.save_to_db(&bob.ctx.sql).await?;
 
         // Step 1: Generate QR-code, ChatId(0) indicates setup-contact
         let qr = get_securejoin_qr(&alice.ctx, None).await?;

src/securejoin/bob.rs

@@ -60,7 +60,7 @@ pub(super) async fn start_protocol(context: &Context, invite: QrInvite) -> Resul
             // TODO: how does this group become usable?
             let group_chat_id = state.joining_chat_id(context).await?;
             if !is_contact_in_chat(context, group_chat_id, invite.contact_id()).await? {
-                chat::add_to_chat_contacts_table(context, group_chat_id, invite.contact_id())
+                chat::add_to_chat_contacts_table(context, group_chat_id, &[invite.contact_id()])
                     .await?;
             }
             let msg = stock_str::secure_join_started(context, invite.contact_id()).await;

src/simplify.rs

@@ -10,7 +10,7 @@
 // (to be only compatible with delta, only "[\r\n|\n]-- {0,2}[\r\n|\n]" needs to be replaced)
 pub fn escape_message_footer_marks(text: &str) -> String {
     if let Some(text) = text.strip_prefix("--") {
-        "-\u{200B}-".to_string() + &text.replace("\n--", "\n-\u{200B}-")
+        format!("-\u{200B}-{}", text.replace("\n--", "\n-\u{200B}-"))
     } else {
         text.replace("\n--", "\n-\u{200B}-")
     }

src/sql.rs

@@ -280,7 +280,7 @@ impl Sql {
             for addr in &addrs {
                 if let Some(ref mut peerstate) = Peerstate::from_addr(context, addr).await? {
                     peerstate.recalc_fingerprint();
-                    peerstate.save_to_db(self, false).await?;
+                    peerstate.save_to_db(self).await?;
                 }
             }
         }
@@ -432,7 +432,7 @@ impl Sql {
     pub async fn transaction<G, H>(&self, callback: G) -> Result<H>
     where
         H: Send + 'static,
-        G: Send + 'static + FnOnce(&mut rusqlite::Transaction<'_>) -> Result<H>,
+        G: Send + FnOnce(&mut rusqlite::Transaction<'_>) -> Result<H>,
     {
         let mut conn = self.get_conn().await?;
         tokio::task::block_in_place(move || {
@@ -528,9 +528,7 @@ impl Sql {
     ///
     /// Setting `None` deletes the value.  On failure an error message
     /// will already have been logged.
-    pub async fn set_raw_config(&self, key: impl AsRef<str>, value: Option<&str>) -> Result<()> {
-        let key = key.as_ref();
-
+    pub async fn set_raw_config(&self, key: &str, value: Option<&str>) -> Result<()> {
         let mut lock = self.config_cache.write().await;
         if let Some(value) = value {
             let exists = self
@@ -564,9 +562,9 @@ impl Sql {
     }
 
     /// Get configuration options from the database.
-    pub async fn get_raw_config(&self, key: impl AsRef<str>) -> Result<Option<String>> {
+    pub async fn get_raw_config(&self, key: &str) -> Result<Option<String>> {
         let lock = self.config_cache.read().await;
-        let cached = lock.get(key.as_ref()).cloned();
+        let cached = lock.get(key).cloned();
         drop(lock);
 
         if let Some(c) = cached {
@@ -575,48 +573,42 @@ impl Sql {
 
         let mut lock = self.config_cache.write().await;
         let value = self
-            .query_get_value(
-                "SELECT value FROM config WHERE keyname=?;",
-                paramsv![key.as_ref()],
-            )
+            .query_get_value("SELECT value FROM config WHERE keyname=?;", paramsv![key])
             .await
-            .context(format!("failed to fetch raw config: {}", key.as_ref()))?;
-        lock.insert(key.as_ref().to_string(), value.clone());
+            .context(format!("failed to fetch raw config: {}", key))?;
+        lock.insert(key.to_string(), value.clone());
         drop(lock);
 
         Ok(value)
     }
 
-    pub async fn set_raw_config_int(&self, key: impl AsRef<str>, value: i32) -> Result<()> {
+    pub async fn set_raw_config_int(&self, key: &str, value: i32) -> Result<()> {
         self.set_raw_config(key, Some(&format!("{}", value))).await
     }
 
-    pub async fn get_raw_config_int(&self, key: impl AsRef<str>) -> Result<Option<i32>> {
+    pub async fn get_raw_config_int(&self, key: &str) -> Result<Option<i32>> {
         self.get_raw_config(key)
             .await
             .map(|s| s.and_then(|s| s.parse().ok()))
     }
 
-    pub async fn get_raw_config_bool(&self, key: impl AsRef<str>) -> Result<bool> {
+    pub async fn get_raw_config_bool(&self, key: &str) -> Result<bool> {
         // Not the most obvious way to encode bool as string, but it is matter
         // of backward compatibility.
         let res = self.get_raw_config_int(key).await?;
         Ok(res.unwrap_or_default() > 0)
     }
 
-    pub async fn set_raw_config_bool<T>(&self, key: T, value: bool) -> Result<()>
-    where
-        T: AsRef<str>,
-    {
+    pub async fn set_raw_config_bool(&self, key: &str, value: bool) -> Result<()> {
         let value = if value { Some("1") } else { None };
         self.set_raw_config(key, value).await
     }
 
-    pub async fn set_raw_config_int64(&self, key: impl AsRef<str>, value: i64) -> Result<()> {
+    pub async fn set_raw_config_int64(&self, key: &str, value: i64) -> Result<()> {
         self.set_raw_config(key, Some(&format!("{}", value))).await
     }
 
-    pub async fn get_raw_config_int64(&self, key: impl AsRef<str>) -> Result<Option<i64>> {
+    pub async fn get_raw_config_int64(&self, key: &str) -> Result<Option<i64>> {
         self.get_raw_config(key)
             .await
             .map(|s| s.and_then(|r| r.parse().ok()))
@@ -728,7 +720,7 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
             |row| row.get::<_, String>(0),
             |rows| {
                 for row in rows {
-                    maybe_add_file(&mut files_in_use, row?);
+                    maybe_add_file(&mut files_in_use, &row?);
                 }
                 Ok(())
             },
@@ -819,8 +811,8 @@ fn is_file_in_use(files_in_use: &HashSet<String>, namespc_opt: Option<&str>, nam
     files_in_use.contains(name_to_check)
 }
 
-fn maybe_add_file(files_in_use: &mut HashSet<String>, file: impl AsRef<str>) {
-    if let Some(file) = file.as_ref().strip_prefix("$BLOBDIR/") {
+fn maybe_add_file(files_in_use: &mut HashSet<String>, file: &str) {
+    if let Some(file) = file.strip_prefix("$BLOBDIR/") {
         files_in_use.insert(file.to_string());
     }
 }

src/sql/migrations.rs

@@ -320,11 +320,11 @@ ALTER TABLE msgs ADD COLUMN ephemeral_timestamp INTEGER DEFAULT 0;"#,
     if dbversion < 67 {
         for prefix in &["", "configured_"] {
             if let Some(server_flags) = sql
-                .get_raw_config_int(format!("{}server_flags", prefix))
+                .get_raw_config_int(&format!("{}server_flags", prefix))
                 .await?
             {
                 let imap_socket_flags = server_flags & 0x700;
-                let key = format!("{}mail_security", prefix);
+                let key = &format!("{}mail_security", prefix);
                 match imap_socket_flags {
                     0x100 => sql.set_raw_config_int(key, 2).await?, // STARTTLS
                     0x200 => sql.set_raw_config_int(key, 1).await?, // SSL/TLS
@@ -332,7 +332,7 @@ ALTER TABLE msgs ADD COLUMN ephemeral_timestamp INTEGER DEFAULT 0;"#,
                     _ => sql.set_raw_config_int(key, 0).await?,
                 }
                 let smtp_socket_flags = server_flags & 0x70000;
-                let key = format!("{}send_security", prefix);
+                let key = &format!("{}send_security", prefix);
                 match smtp_socket_flags {
                     0x10000 => sql.set_raw_config_int(key, 2).await?, // STARTTLS
                     0x20000 => sql.set_raw_config_int(key, 1).await?, // SSL/TLS
@@ -616,6 +616,50 @@ CREATE INDEX smtp_messageid ON imap(rfc724_mid);
         )
         .await?;
     }
+    if dbversion < 94 {
+        sql.execute_migration(
+            // Create new `acpeerstates` table, same as before but with unique constraint.
+            //
+            // This allows to use `UPSERT` to update existing or insert a new peerstate
+            // depending on whether one exists already.
+            "CREATE TABLE new_acpeerstates (
+             id INTEGER PRIMARY KEY,
+             addr TEXT DEFAULT '' COLLATE NOCASE,
+             last_seen INTEGER DEFAULT 0,
+             last_seen_autocrypt INTEGER DEFAULT 0,
+             public_key,
+             prefer_encrypted INTEGER DEFAULT 0,
+             gossip_timestamp INTEGER DEFAULT 0,
+             gossip_key,
+             public_key_fingerprint TEXT DEFAULT '',
+             gossip_key_fingerprint TEXT DEFAULT '',
+             verified_key,
+             verified_key_fingerprint TEXT DEFAULT '',
+             UNIQUE (addr) -- Only one peerstate per address
+             );
+            INSERT OR IGNORE INTO new_acpeerstates SELECT * FROM acpeerstates;
+            DROP TABLE acpeerstates;
+            ALTER TABLE new_acpeerstates RENAME TO acpeerstates;
+            CREATE INDEX acpeerstates_index1 ON acpeerstates (addr);
+            CREATE INDEX acpeerstates_index3 ON acpeerstates (public_key_fingerprint);
+            CREATE INDEX acpeerstates_index4 ON acpeerstates (gossip_key_fingerprint);
+            CREATE INDEX acpeerstates_index5 ON acpeerstates (verified_key_fingerprint);
+            ",
+            94,
+        )
+        .await?;
+    }
+    if dbversion < 95 {
+        sql.execute_migration(
+            "CREATE TABLE new_chats_contacts (chat_id INTEGER, contact_id INTEGER, UNIQUE(chat_id, contact_id));\
+            INSERT OR IGNORE INTO new_chats_contacts SELECT * FROM chats_contacts;\
+            DROP TABLE chats_contacts;\
+            ALTER TABLE new_chats_contacts RENAME TO chats_contacts;\
+            CREATE INDEX chats_contacts_index1 ON chats_contacts (chat_id);\
+            CREATE INDEX chats_contacts_index2 ON chats_contacts (contact_id);",
+            95
+        ).await?;
+    }
 
     let new_version = sql
         .get_raw_config_int(VERSION_CFG)

src/stock_str.rs

@@ -17,7 +17,7 @@ use crate::context::Context;
 use crate::message::{Message, Viewtype};
 use crate::param::Param;
 use crate::tools::timestamp_to_str;
-use humansize::{file_size_opts, FileSize};
+use humansize::{format_size, BINARY};
 
 #[derive(Debug, Clone)]
 pub struct StockStrings {
@@ -466,33 +466,33 @@ async fn translated(context: &Context, id: StockMessage) -> String {
 /// Helper trait only meant to be implemented for [`String`].
 trait StockStringMods: AsRef<str> + Sized {
     /// Substitutes the first replacement value if one is present.
-    fn replace1(&self, replacement: impl AsRef<str>) -> String {
+    fn replace1(&self, replacement: &str) -> String {
         self.as_ref()
-            .replacen("%1$s", replacement.as_ref(), 1)
-            .replacen("%1$d", replacement.as_ref(), 1)
-            .replacen("%1$@", replacement.as_ref(), 1)
+            .replacen("%1$s", replacement, 1)
+            .replacen("%1$d", replacement, 1)
+            .replacen("%1$@", replacement, 1)
     }
 
     /// Substitutes the second replacement value if one is present.
     ///
     /// Be aware you probably should have also called [`StockStringMods::replace1`] if
     /// you are calling this.
-    fn replace2(&self, replacement: impl AsRef<str>) -> String {
+    fn replace2(&self, replacement: &str) -> String {
         self.as_ref()
-            .replacen("%2$s", replacement.as_ref(), 1)
-            .replacen("%2$d", replacement.as_ref(), 1)
-            .replacen("%2$@", replacement.as_ref(), 1)
+            .replacen("%2$s", replacement, 1)
+            .replacen("%2$d", replacement, 1)
+            .replacen("%2$@", replacement, 1)
     }
 
     /// Substitutes the third replacement value if one is present.
     ///
     /// Be aware you probably should have also called [`StockStringMods::replace1`] and
     /// [`StockStringMods::replace2`] if you are calling this.
-    fn replace3(&self, replacement: impl AsRef<str>) -> String {
+    fn replace3(&self, replacement: &str) -> String {
         self.as_ref()
-            .replacen("%3$s", replacement.as_ref(), 1)
-            .replacen("%3$d", replacement.as_ref(), 1)
-            .replacen("%3$@", replacement.as_ref(), 1)
+            .replacen("%3$s", replacement, 1)
+            .replacen("%3$d", replacement, 1)
+            .replacen("%3$@", replacement, 1)
     }
 }
 
@@ -551,8 +551,8 @@ pub(crate) async fn file(context: &Context) -> String {
 /// Stock string: `Group name changed from "%1$s" to "%2$s".`.
 pub(crate) async fn msg_grp_name(
     context: &Context,
-    from_group: impl AsRef<str>,
-    to_group: impl AsRef<str>,
+    from_group: &str,
+    to_group: &str,
     by_contact: ContactId,
 ) -> String {
     if by_contact == ContactId::SELF {
@@ -565,7 +565,7 @@ pub(crate) async fn msg_grp_name(
             .await
             .replace1(from_group)
             .replace2(to_group)
-            .replace3(by_contact.get_stock_name(context).await)
+            .replace3(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -575,7 +575,7 @@ pub(crate) async fn msg_grp_img_changed(context: &Context, by_contact: ContactId
     } else {
         translated(context, StockMessage::MsgGrpImgChangedBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -585,11 +585,11 @@ pub(crate) async fn msg_grp_img_changed(context: &Context, by_contact: ContactId
 /// contacts to combine with the display name.
 pub(crate) async fn msg_add_member(
     context: &Context,
-    added_member_addr: impl AsRef<str>,
+    added_member_addr: &str,
     by_contact: ContactId,
 ) -> String {
-    let addr = added_member_addr.as_ref();
-    let who = match Contact::lookup_id_by_addr(context, addr, Origin::Unknown).await {
+    let addr = added_member_addr;
+    let who = &match Contact::lookup_id_by_addr(context, addr, Origin::Unknown).await {
         Ok(Some(contact_id)) => Contact::get_by_id(context, contact_id)
             .await
             .map(|contact| contact.get_name_n_addr())
@@ -604,7 +604,7 @@ pub(crate) async fn msg_add_member(
         translated(context, StockMessage::MsgAddMemberBy)
             .await
             .replace1(who)
-            .replace2(by_contact.get_stock_name(context).await)
+            .replace2(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -614,11 +614,11 @@ pub(crate) async fn msg_add_member(
 /// the contacts to combine with the display name.
 pub(crate) async fn msg_del_member(
     context: &Context,
-    removed_member_addr: impl AsRef<str>,
+    removed_member_addr: &str,
     by_contact: ContactId,
 ) -> String {
-    let addr = removed_member_addr.as_ref();
-    let who = match Contact::lookup_id_by_addr(context, addr, Origin::Unknown).await {
+    let addr = removed_member_addr;
+    let who = &match Contact::lookup_id_by_addr(context, addr, Origin::Unknown).await {
         Ok(Some(contact_id)) => Contact::get_by_id(context, contact_id)
             .await
             .map(|contact| contact.get_name_n_addr())
@@ -633,7 +633,7 @@ pub(crate) async fn msg_del_member(
         translated(context, StockMessage::MsgDelMemberBy)
             .await
             .replace1(who)
-            .replace2(by_contact.get_stock_name(context).await)
+            .replace2(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -644,7 +644,7 @@ pub(crate) async fn msg_group_left(context: &Context, by_contact: ContactId) ->
     } else {
         translated(context, StockMessage::MsgGroupLeftBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -684,7 +684,7 @@ pub(crate) async fn read_rcpt(context: &Context) -> String {
 }
 
 /// Stock string: `This is a return receipt for the message "%1$s".`.
-pub(crate) async fn read_rcpt_mail_body(context: &Context, message: impl AsRef<str>) -> String {
+pub(crate) async fn read_rcpt_mail_body(context: &Context, message: &str) -> String {
     translated(context, StockMessage::ReadRcptMailBody)
         .await
         .replace1(message)
@@ -697,7 +697,7 @@ pub(crate) async fn msg_grp_img_deleted(context: &Context, by_contact: ContactId
     } else {
         translated(context, StockMessage::MsgGrpImgDeletedBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -714,7 +714,7 @@ pub(crate) async fn secure_join_started(
     if let Ok(contact) = Contact::get_by_id(context, inviter_contact_id).await {
         translated(context, StockMessage::SecureJoinStarted)
             .await
-            .replace1(contact.get_name_n_addr())
+            .replace1(&contact.get_name_n_addr())
             .replace2(contact.get_display_name())
     } else {
         format!(
@@ -741,7 +741,7 @@ pub(crate) async fn setup_contact_qr_description(
     display_name: &str,
     addr: &str,
 ) -> String {
-    let name = if display_name == addr {
+    let name = &if display_name == addr {
         addr.to_owned()
     } else {
         format!("{} ({})", display_name, addr)
@@ -760,7 +760,7 @@ pub(crate) async fn secure_join_group_qr_description(context: &Context, chat: &C
 
 /// Stock string: `%1$s verified.`.
 pub(crate) async fn contact_verified(context: &Context, contact: &Contact) -> String {
-    let addr = contact.get_name_n_addr();
+    let addr = &contact.get_name_n_addr();
     translated(context, StockMessage::ContactVerified)
         .await
         .replace1(addr)
@@ -768,17 +768,14 @@ pub(crate) async fn contact_verified(context: &Context, contact: &Contact) -> St
 
 /// Stock string: `Cannot verify %1$s`.
 pub(crate) async fn contact_not_verified(context: &Context, contact: &Contact) -> String {
-    let addr = contact.get_name_n_addr();
+    let addr = &contact.get_name_n_addr();
     translated(context, StockMessage::ContactNotVerified)
         .await
         .replace1(addr)
 }
 
 /// Stock string: `Changed setup for %1$s`.
-pub(crate) async fn contact_setup_changed(
-    context: &Context,
-    contact_addr: impl AsRef<str>,
-) -> String {
+pub(crate) async fn contact_setup_changed(context: &Context, contact_addr: &str) -> String {
     translated(context, StockMessage::ContactSetupChanged)
         .await
         .replace1(contact_addr)
@@ -810,7 +807,7 @@ pub(crate) async fn sync_msg_body(context: &Context) -> String {
 }
 
 /// Stock string: `Cannot login as \"%1$s\". Please check...`.
-pub(crate) async fn cannot_login(context: &Context, user: impl AsRef<str>) -> String {
+pub(crate) async fn cannot_login(context: &Context, user: &str) -> String {
     translated(context, StockMessage::CannotLogin)
         .await
         .replace1(user)
@@ -828,7 +825,7 @@ pub(crate) async fn msg_location_enabled_by(context: &Context, contact: ContactI
     } else {
         translated(context, StockMessage::MsgLocationEnabledBy)
             .await
-            .replace1(contact.get_stock_name(context).await)
+            .replace1(&contact.get_stock_name(context).await)
     }
 }
 
@@ -874,17 +871,14 @@ pub(crate) async fn unknown_sender_for_chat(context: &Context) -> String {
 
 /// Stock string: `Message from %1$s`.
 // TODO: This can compute `self_name` itself instead of asking the caller to do this.
-pub(crate) async fn subject_for_new_contact(
-    context: &Context,
-    self_name: impl AsRef<str>,
-) -> String {
+pub(crate) async fn subject_for_new_contact(context: &Context, self_name: &str) -> String {
     translated(context, StockMessage::SubjectForNewContact)
         .await
         .replace1(self_name)
 }
 
 /// Stock string: `Failed to send message to %1$s.`.
-pub(crate) async fn failed_sending_to(context: &Context, name: impl AsRef<str>) -> String {
+pub(crate) async fn failed_sending_to(context: &Context, name: &str) -> String {
     translated(context, StockMessage::FailedSendingTo)
         .await
         .replace1(name)
@@ -900,14 +894,14 @@ pub(crate) async fn msg_ephemeral_timer_disabled(
     } else {
         translated(context, StockMessage::MsgEphemeralTimerDisabledBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
 /// Stock string: `Message deletion timer is set to %1$s s.`.
 pub(crate) async fn msg_ephemeral_timer_enabled(
     context: &Context,
-    timer: impl AsRef<str>,
+    timer: &str,
     by_contact: ContactId,
 ) -> String {
     if by_contact == ContactId::SELF {
@@ -918,7 +912,7 @@ pub(crate) async fn msg_ephemeral_timer_enabled(
         translated(context, StockMessage::MsgEphemeralTimerEnabledBy)
             .await
             .replace1(timer)
-            .replace2(by_contact.get_stock_name(context).await)
+            .replace2(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -929,7 +923,7 @@ pub(crate) async fn msg_ephemeral_timer_minute(context: &Context, by_contact: Co
     } else {
         translated(context, StockMessage::MsgEphemeralTimerMinuteBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -940,7 +934,7 @@ pub(crate) async fn msg_ephemeral_timer_hour(context: &Context, by_contact: Cont
     } else {
         translated(context, StockMessage::MsgEphemeralTimerHourBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -951,7 +945,7 @@ pub(crate) async fn msg_ephemeral_timer_day(context: &Context, by_contact: Conta
     } else {
         translated(context, StockMessage::MsgEphemeralTimerDayBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -962,7 +956,7 @@ pub(crate) async fn msg_ephemeral_timer_week(context: &Context, by_contact: Cont
     } else {
         translated(context, StockMessage::MsgEphemeralTimerWeekBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -972,14 +966,14 @@ pub(crate) async fn videochat_invitation(context: &Context) -> String {
 }
 
 /// Stock string: `You are invited to a video chat, click %1$s to join.`.
-pub(crate) async fn videochat_invite_msg_body(context: &Context, url: impl AsRef<str>) -> String {
+pub(crate) async fn videochat_invite_msg_body(context: &Context, url: &str) -> String {
     translated(context, StockMessage::VideochatInviteMsgBody)
         .await
         .replace1(url)
 }
 
 /// Stock string: `Error:\n\n“%1$s”`.
-pub(crate) async fn configuration_failed(context: &Context, details: impl AsRef<str>) -> String {
+pub(crate) async fn configuration_failed(context: &Context, details: &str) -> String {
     translated(context, StockMessage::ConfigurationFailed)
         .await
         .replace1(details)
@@ -987,7 +981,7 @@ pub(crate) async fn configuration_failed(context: &Context, details: impl AsRef<
 
 /// Stock string: `⚠️ Date or time of your device seem to be inaccurate (%1$s)...`.
 // TODO: This could compute now itself.
-pub(crate) async fn bad_time_msg_body(context: &Context, now: impl AsRef<str>) -> String {
+pub(crate) async fn bad_time_msg_body(context: &Context, now: &str) -> String {
     translated(context, StockMessage::BadTimeMsgBody)
         .await
         .replace1(now)
@@ -1010,7 +1004,7 @@ pub(crate) async fn protection_enabled(context: &Context, by_contact: ContactId)
     } else {
         translated(context, StockMessage::ProtectionEnabledBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -1021,7 +1015,7 @@ pub(crate) async fn protection_disabled(context: &Context, by_contact: ContactId
     } else {
         translated(context, StockMessage::ProtectionDisabledBy)
             .await
-            .replace1(by_contact.get_stock_name(context).await)
+            .replace1(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -1043,7 +1037,7 @@ pub(crate) async fn delete_server_turned_off(context: &Context) -> String {
 /// Stock string: `Message deletion timer is set to %1$s minutes.`.
 pub(crate) async fn msg_ephemeral_timer_minutes(
     context: &Context,
-    minutes: impl AsRef<str>,
+    minutes: &str,
     by_contact: ContactId,
 ) -> String {
     if by_contact == ContactId::SELF {
@@ -1054,14 +1048,14 @@ pub(crate) async fn msg_ephemeral_timer_minutes(
         translated(context, StockMessage::MsgEphemeralTimerMinutesBy)
             .await
             .replace1(minutes)
-            .replace2(by_contact.get_stock_name(context).await)
+            .replace2(&by_contact.get_stock_name(context).await)
     }
 }
 
 /// Stock string: `Message deletion timer is set to %1$s hours.`.
 pub(crate) async fn msg_ephemeral_timer_hours(
     context: &Context,
-    hours: impl AsRef<str>,
+    hours: &str,
     by_contact: ContactId,
 ) -> String {
     if by_contact == ContactId::SELF {
@@ -1072,14 +1066,14 @@ pub(crate) async fn msg_ephemeral_timer_hours(
         translated(context, StockMessage::MsgEphemeralTimerHoursBy)
             .await
             .replace1(hours)
-            .replace2(by_contact.get_stock_name(context).await)
+            .replace2(&by_contact.get_stock_name(context).await)
     }
 }
 
 /// Stock string: `Message deletion timer is set to %1$s days.`.
 pub(crate) async fn msg_ephemeral_timer_days(
     context: &Context,
-    days: impl AsRef<str>,
+    days: &str,
     by_contact: ContactId,
 ) -> String {
     if by_contact == ContactId::SELF {
@@ -1090,14 +1084,14 @@ pub(crate) async fn msg_ephemeral_timer_days(
         translated(context, StockMessage::MsgEphemeralTimerDaysBy)
             .await
             .replace1(days)
-            .replace2(by_contact.get_stock_name(context).await)
+            .replace2(&by_contact.get_stock_name(context).await)
     }
 }
 
 /// Stock string: `Message deletion timer is set to %1$s weeks.`.
 pub(crate) async fn msg_ephemeral_timer_weeks(
     context: &Context,
-    weeks: impl AsRef<str>,
+    weeks: &str,
     by_contact: ContactId,
 ) -> String {
     if by_contact == ContactId::SELF {
@@ -1108,7 +1102,7 @@ pub(crate) async fn msg_ephemeral_timer_weeks(
         translated(context, StockMessage::MsgEphemeralTimerWeeksBy)
             .await
             .replace1(weeks)
-            .replace2(by_contact.get_stock_name(context).await)
+            .replace2(&by_contact.get_stock_name(context).await)
     }
 }
 
@@ -1121,15 +1115,13 @@ pub(crate) async fn forwarded(context: &Context) -> String {
 pub(crate) async fn quota_exceeding(context: &Context, highest_usage: u64) -> String {
     translated(context, StockMessage::QuotaExceedingMsgBody)
         .await
-        .replace1(format!("{}", highest_usage))
+        .replace1(&format!("{}", highest_usage))
         .replace("%%", "%")
 }
 
 /// Stock string: `%1$s message` with placeholder replaced by human-readable size.
 pub(crate) async fn partial_download_msg_body(context: &Context, org_bytes: u32) -> String {
-    let size = org_bytes
-        .file_size(file_size_opts::BINARY)
-        .unwrap_or_default();
+    let size = &format_size(org_bytes, BINARY);
     translated(context, StockMessage::PartialDownloadMsgBody)
         .await
         .replace1(size)
@@ -1139,7 +1131,7 @@ pub(crate) async fn partial_download_msg_body(context: &Context, org_bytes: u32)
 pub(crate) async fn download_availability(context: &Context, timestamp: i64) -> String {
     translated(context, StockMessage::DownloadAvailability)
         .await
-        .replace1(timestamp_to_str(timestamp))
+        .replace1(&timestamp_to_str(timestamp))
 }
 
 /// Stock string: `Incoming Messages`.
@@ -1154,7 +1146,7 @@ pub(crate) async fn outgoing_messages(context: &Context) -> String {
 
 /// Stock string: `Storage on %1$s`.
 /// `%1$s` will be replaced by the domain of the configured email-address.
-pub(crate) async fn storage_on_domain(context: &Context, domain: impl AsRef<str>) -> String {
+pub(crate) async fn storage_on_domain(context: &Context, domain: &str) -> String {
     translated(context, StockMessage::StorageOnDomain)
         .await
         .replace1(domain)
@@ -1192,7 +1184,7 @@ pub(crate) async fn last_msg_sent_successfully(context: &Context) -> String {
 
 /// Stock string: `Error: %1$s…`.
 /// `%1$s` will be replaced by a possibly more detailed, typically english, error description.
-pub(crate) async fn error(context: &Context, error: impl AsRef<str>) -> String {
+pub(crate) async fn error(context: &Context, error: &str) -> String {
     translated(context, StockMessage::Error)
         .await
         .replace1(error)
@@ -1210,11 +1202,7 @@ pub(crate) async fn messages(context: &Context) -> String {
 }
 
 /// Stock string: `%1$s of %2$s used`.
-pub(crate) async fn part_of_total_used(
-    context: &Context,
-    part: impl AsRef<str>,
-    total: impl AsRef<str>,
-) -> String {
+pub(crate) async fn part_of_total_used(context: &Context, part: &str, total: &str) -> String {
     translated(context, StockMessage::PartOfTotallUsed)
         .await
         .replace1(part)
@@ -1230,9 +1218,9 @@ pub(crate) async fn broadcast_list(context: &Context) -> String {
 /// Stock string: `%1$s changed their address from %2$s to %3$s`.
 pub(crate) async fn aeap_addr_changed(
     context: &Context,
-    contact_name: impl AsRef<str>,
-    old_addr: impl AsRef<str>,
-    new_addr: impl AsRef<str>,
+    contact_name: &str,
+    old_addr: &str,
+    new_addr: &str,
 ) -> String {
     translated(context, StockMessage::AeapAddrChanged)
         .await
@@ -1243,8 +1231,8 @@ pub(crate) async fn aeap_addr_changed(
 
 pub(crate) async fn aeap_explanation_and_link(
     context: &Context,
-    old_addr: impl AsRef<str>,
-    new_addr: impl AsRef<str>,
+    old_addr: &str,
+    new_addr: &str,
 ) -> String {
     translated(context, StockMessage::AeapExplanationAndLink)
         .await

src/test_utils.rs

@@ -979,7 +979,7 @@ fn print_event(event: &Event) {
 /// Logs an individual message to stdout.
 ///
 /// This includes a bunch of the message meta-data as well.
-async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
+async fn log_msg(context: &Context, prefix: &str, msg: &Message) {
     let contact = match Contact::get_by_id(context, msg.get_from_id()).await {
         Ok(contact) => contact,
         Err(e) => {
@@ -1001,7 +1001,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
     let msgtext = msg.get_text();
     println!(
         "{}{}{}{}: {} (Contact#{}): {} {}{}{}{}{}",
-        prefix.as_ref(),
+        prefix,
         msg.get_id(),
         if msg.get_showpadlock() { "🔒" } else { "" },
         if msg.has_location() { "📍" } else { "" },

src/tests/aeap.rs

@@ -341,9 +341,8 @@ async fn mark_as_verified(this: &TestContext, other: &TestContext) {
 
     peerstate.verified_key = peerstate.public_key.clone();
     peerstate.verified_key_fingerprint = peerstate.public_key_fingerprint.clone();
-    peerstate.to_save = Some(peerstate::ToSave::All);
 
-    peerstate.save_to_db(&this.sql, false).await.unwrap();
+    peerstate.save_to_db(&this.sql).await.unwrap();
 }
 
 async fn get_last_info_msg(t: &TestContext, chat_id: ChatId) -> Option<Message> {

src/tools.rs

@@ -113,7 +113,7 @@ pub(crate) fn truncate_by_lines(
  ******************************************************************************/
 
 pub fn timestamp_to_str(wanted: i64) -> String {
-    let ts = Local.timestamp(wanted, 0);
+    let ts = Local.timestamp_opt(wanted, 0).unwrap();
     ts.format("%Y.%m.%d %H:%M:%S").to_string()
 }
 
@@ -206,8 +206,9 @@ async fn maybe_warn_on_bad_time(context: &Context, now: i64, known_past_timestam
         msg.text = Some(
             stock_str::bad_time_msg_body(
                 context,
-                Local
-                    .timestamp(now, 0)
+                &Local
+                    .timestamp_opt(now, 0)
+                    .unwrap()
                     .format("%Y-%m-%d %H:%M:%S")
                     .to_string(),
             )
@@ -218,7 +219,9 @@ async fn maybe_warn_on_bad_time(context: &Context, now: i64, known_past_timestam
             Some(
                 format!(
                     "bad-time-warning-{}",
-                    chrono::NaiveDateTime::from_timestamp(now, 0).format("%Y-%m-%d") // repeat every day
+                    chrono::NaiveDateTime::from_timestamp_opt(now, 0)
+                        .unwrap()
+                        .format("%Y-%m-%d") // repeat every day
                 )
                 .as_str(),
             ),
@@ -241,7 +244,9 @@ async fn maybe_warn_on_outdated(context: &Context, now: i64, approx_compile_time
             Some(
                 format!(
                     "outdated-warning-{}",
-                    chrono::NaiveDateTime::from_timestamp(now, 0).format("%Y-%m") // repeat every month
+                    chrono::NaiveDateTime::from_timestamp_opt(now, 0)
+                        .unwrap()
+                        .format("%Y-%m") // repeat every month
                 )
                 .as_str(),
             ),
@@ -319,8 +324,8 @@ pub(crate) fn extract_grpid_from_rfc724_mid(mid: &str) -> Option<&str> {
 }
 
 // the returned suffix is lower-case
-pub fn get_filesuffix_lc(path_filename: impl AsRef<str>) -> Option<String> {
-    Path::new(path_filename.as_ref())
+pub fn get_filesuffix_lc(path_filename: &str) -> Option<String> {
+    Path::new(path_filename)
         .extension()
         .map(|p| p.to_string_lossy().to_lowercase())
 }
@@ -648,9 +653,9 @@ pub(crate) fn parse_receive_header(header: &str) -> String {
     if let Ok(date) = dateparse(&header) {
         // In tests, use the UTC timezone so that the test is reproducible
         #[cfg(test)]
-        let date_obj = chrono::Utc.timestamp(date, 0);
+        let date_obj = chrono::Utc.timestamp_opt(date, 0).unwrap();
         #[cfg(not(test))]
-        let date_obj = Local.timestamp(date, 0);
+        let date_obj = Local.timestamp_opt(date, 0).unwrap();
 
         hop_info += &format!("Date: {}", date_obj.to_rfc2822());
     };
@@ -670,6 +675,18 @@ pub(crate) fn parse_receive_headers(headers: &Headers) -> String {
         .join("\n")
 }
 
+/// If `collection` contains exactly one element, return this element.
+/// Otherwise, return None.
+pub(crate) fn single_value<T>(collection: impl IntoIterator<Item = T>) -> Option<T> {
+    let mut iter = collection.into_iter();
+    if let Some(value) = iter.next() {
+        if iter.next().is_none() {
+            return Some(value);
+        }
+    }
+    None
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::indexing_slicing)]
@@ -1141,8 +1158,8 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         let timestamp_now = time();
         let timestamp_future = timestamp_now + 60 * 60 * 24 * 7;
         let timestamp_past = NaiveDateTime::new(
-            NaiveDate::from_ymd(2020, 9, 1),
-            NaiveTime::from_hms(0, 0, 0),
+            NaiveDate::from_ymd_opt(2020, 9, 1).unwrap(),
+            NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
         )
         .timestamp_millis()
             / 1_000;

test-data/message/thunderbird_with_autocrypt.eml

@@ -0,0 +1,93 @@
+From - Thu, 24 Nov 2022 19:06:16 GMT
+X-Mozilla-Status: 0001
+X-Mozilla-Status2: 00800000
+Message-ID: <0bb9ffe1-2596-d997-95b4-1fef8cc4808e@example.org>
+Date: Thu, 24 Nov 2022 20:05:57 +0100
+MIME-Version: 1.0
+User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101
+ Thunderbird/102.4.2
+From: Alice <alice@example.org>
+To: bob@example.net
+Content-Language: en-US
+Autocrypt: addr=alice@example.org; keydata=
+ xjMEXlh13RYJKwYBBAHaRw8BAQdAzfVIAleCXMJrq8VeLlEVof6ITCviMktKjmcBKAu4m5DN
+ GUFsaWNlIDxhbGljZUBleGFtcGxlLm9yZz7CkAQTFggAOBYhBC5vossjtTLXKGNLWGSwj2Gp
+ 7ZRDBQJeWHXdAhsDBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEGSwj2Gp7ZRDE3oA/i4M
+ CyDMTsjWqDZoQwX/A/GoTO2/V0wKPhjJJy/8m2pMAPkBjOnGOtx2SZpQvJGTa9h804RY6iDr
+ RuI8A/8tEEXAA844BF5Ydd0SCisGAQQBl1UBBQEBB0AG7cjWy2SFAU8KnltlubVW67rFiyfp
+ 01JrRe6Xqy22HQMBCAfCeAQYFggAIBYhBC5vossjtTLXKGNLWGSwj2Gp7ZRDBQJeWHXdAhsM
+ AAoJEGSwj2Gp7ZRDLo8BAObE8GnsGVwKzNqCvHeWgJsqhjS3C6gvSlV3tEm9XmF6AQDXucIy
+ VfoBwoyMh2h6cSn/ATn5QJb35pgo+ivp3jsMAg==
+Subject: ...
+Content-Type: multipart/encrypted;
+ protocol="application/pgp-encrypted";
+ boundary="------------EOdOT2kJUL5hgCilmIhYyVZg"
+
+This is an OpenPGP/MIME encrypted message (RFC 4880 and 3156)
+--------------EOdOT2kJUL5hgCilmIhYyVZg
+Content-Type: application/pgp-encrypted
+Content-Description: PGP/MIME version identification
+
+Version: 1
+
+--------------EOdOT2kJUL5hgCilmIhYyVZg
+Content-Type: application/octet-stream; name="encrypted.asc"
+Content-Description: OpenPGP encrypted message
+Content-Disposition: inline; filename="encrypted.asc"
+
+-----BEGIN PGP MESSAGE-----
+
+wV4D5tq63hTeebASAQdA1dVUsUjGZCOIfCnYtVdmOvKs/BNovI3sG8w1IH4ymTMwAZzgwVbGS5KL
++e1VTD5mUTeVSEYe1cd3VozH4KbNJa1tBlcO0nzGwCPpsTVDMoxIwcBMA+PY3JvEjuMiAQf/d2yj
+t0+GyaptwX26bgSqo6vj21W8mcWS5vXOi8wjGwRbPaKKjS4kq1xDOz04eHrE8HUPD8otcXoI8CLz
+etJpRbFs0XJP4Cozbsr72dgoWhozRg/iSpBndxWOddTl7Yqo8m/fyhU5uzKZ41m2T8mha6KkKWD8
+QecGdOgieYBucNBjHwWc71p9G6jTnzfy4S4GtGS2gwOSMxpwO7HxpKzsHI4POqFSQbxrl/YRwWSC
+f5WqyYcerasIiR/fnOIw8lnvCeQ5rB90eGEDR70YFGt0t4rFBjfGrSPUiWYaTaC1Zvpd+t5sy7zy
+FpsS2/aTkwP/UpGqmtFaD/brSouRf9hijNLI0QFTaVmSoI3BKzF8B4zwvtEbOLZjyDb+Va/fZJ3w
+nYd2Q/5PPPL+pE4pWKN+jl0TZNzAaqBgvggXomgUqQ7QiksUzym+yuFKrJX0RF2awdrgjQIxjnda
+Qp3UFphnFTyYUJpIU9iewjOfVxgPzv7PyuCHYwoP3kh7MJZ6bgbDmOkeFSnjEDJpdf1m9xC9LlBL
+beC8scmPs6kx9GARBYSHvyPQ025gN3+XEHh4OrTxHZ91U3IlTfd2kACwOOAXEuhItSHmcNOV0K4M
+nI2PH6gW8HgBkWlAPm40K4jUyo3nl1usDiI6ouvYqvW7YUc2hTtPTej1l2/mS57tTt+PFurKs555
+5R9DD/xg9Nx7OuQKy5bIdlXM20UmwuZTOhRJ5kpHFRzLxaHDbSzW+orhRW4llJSevBSAH3cLOjIQ
+gh87j+MxG9j0TD2K2A0rcUcxdrnflw+mxcDVaL4payeqmOa+bJyhlftTqH+vqq5DhR68rX5VW+z7
+riqH3o8VbvO2y0XSpYHf1jowkfJj3vr8pynAUIv1dbylUSF5wtrHvzWOprw4bNrdtwQNRNy+JcVF
+dUKeNmHaL6XOe4LUWpiI11beRyCpAG52khMCEAO3Q6+4e24cEipbu6suSOtv3OpYDZeHjwNrQIhi
+rJg7i9TpMqwOeCvFWK+9UZ+P2n6h9g0/JO2+I82BFGUjVa5IvCTNOgv01GqxWY9ecdtaJjTc+dF2
+OAcRoKwvmtMJlxKEEgveui3BvPA4tuNdSrcoZBrQeo0ZHWVugXPvEZnwfZMcqwwPA+a/sUbZFg0P
+Pr0AR0ZHpytnQE9OXE8wEUgT8H1yofQ+5QoZdgMpeAb8zGs+RuviLxcDkb9NtXUAiQ49ooWuFP3L
+K9wMlaoWFTq7R+n5JVuSEYRCHC0l0bCV1/+awalT7XltXVCupI4lWzjYs52FZGGzuHG7S50Eufad
+m4CQTPVgVaVn8WW2dmpMR8Gj8WbbZdyv21wMGOWjfgT0u3oiDnddGrFOoMNnZHch6rN3FRppoh7h
+0U0fi8xxU1+EhUKq+fSIxZNr2iWN2if3Pipbxi9tyK9M41Y6aVF3HWjD58/OEql3aZjJZ1bqpXcE
+qsPeFoXX78+7mTDvL75olMk2s/mg4mLqAAWQvTuoiOmj+SgMIFuTtFR+4r/TIFNdamz6AQ3RcmWG
+ZcdRii+V27dtMA836vlAwxXRmJyE1LCL1kvUTq+J+AVsZi3xmBLFNlKPTlxswu7vSBrP1DlYOaBq
+AgA0lKnkQdeXyDk/VdbTml7ywMW1g6HkFSqKGW/IIAObmBumBcIyHE6dWEHumRQomlJssIlEFSe+
+XEQ0rwedLetJXi5A0AXT1we1wvaKCEg0Pb0ZUxygwNPDrj6MmdodH7gDfyx0mW/7mEMCtIJb5MB+
+TRGPEa/vqdJb8uGtNXUy9UlwMhJ3tYoT7NXY4+IlNjbDH/yleMdwtWP2H2WH8oC+ysXPYXjlT8eU
+poxRfJzPMVUn5SA3cvdGXDJWdX8U91j5sf9wuoYE5RBVrrJif3D3l0FpMrlWWoGw7wtZbMC2FaeT
+QvdMS5c54IoXBtBTM+/AsTAw7WEE1QSmaQGHnh6xLL5Ns8olsWeKOMlVXdO9jSDbjOGBLr7mWukW
+YzLXkH3TtJPQcbVN79af3YPhaHdMYITVKIwfg+vxZlLFHWLJQnkTl+9Qi7u2gKqkNeU7Zqs4E3CR
+9K4dHrJMyAZLZ2HA1XQEj0/tMnbTpAzZhj02JRcFobLXK9SQfw7dzGZwMRky8cHcBHoK14P5RIEV
+hr+38HSBM6wXtge5gL6DomAACvuORQO4X9x/CTjRt/J8uN3lKK5p+wi3ULeb319CEWiCiqmC1M+C
+TADUhPUhUmTinSAVkTEn+BdbH/97dVaJnvd6HtLmdSlw4xqdWUfVL9Qd7+/5L6iwlOzGLKRv97c/
+gCRw+hzXyAom+5C18slSwanMuyPgIyrrFy/kp9Romk9SQr/c0CUF2am99t8G5qvVi/TiJGHyKEXD
+aUYd4V7lqNlHMiiasvFHeq8blwmFr7rGEvbZzLNplc6sRUVlYhY2unRfyWsq9mqk3NDRW12Fa0J2
+YxQJlnXHQhNE8EyM/zsD9jCVNwsRZJ9/e5KS+ignmu6gKIR+ItDTwRfNI+NG/YmTgENUTyuO+vQC
+CUKS3PCwpP+OEC966ARl7OCMdfn1hEyiAxsZnp1RmFngR6FM+mlGgfUoWNoHvnR1/YyQ4F4dadiA
+QINwuSm5faw75F1EeL8Qi+LHKuqt05Pi/V9GJ6TzIkIsEbyyJ5sKHrp4QsU4C1p7ZhPjddz8De8k
+6ZdwMIeXxi27WKtsFLcr8JKOBe0imIilKdMBOPS31pc1iJe4472WbWM0aBwdEYmnz9+xfOqnjHtO
+0XTMjff7pzV6Y7t/u8J/zm3JS3ykote9HNRQvhZZNeVClVWd0fYFzat5ESnTojZTwHcc/BFTPnhz
+VgLyw1KEIy2r3ZyGHu1b8GSYivzl33MOK/NVBQPZUIEfdcQ5vhkAvj+Yx340IYykRFEChwioprXD
+LrIbTou7TNT5fTFA+beidHFsL+OE002/LMs6C3erSUW5C/LNjAQMS7cAV2yCyjX+/2GBmmDqnC4r
+Ja2x5yik+fbOUPh3kk/md1YvrodlX/JkQeoWRrrVJsX2dr3BgivPJavaN0Jz1eHyxAYKNqlrfd1T
+YWEDIisWerTxAVY/rEruZ6+OqLqOtZtn+4SOajOq8KFusglaMZqoYuM+LhPZck9PlZXwRqX08Vlv
+8jX5V75BFWRhFd5/LYbnQHI6ZW80Wb2sBNngLL2QJT9yXGCDJb5qCdFwGd3i655pvRJXabeyCtDD
+7I2PJcYRDd4stdq07BHyHJmye6vas8mG5QUygyWyUQv78za0m4gLMrRZBgoBDcVpWJUc+cPXzzfG
+7PvLZu/Y0SaD5hqTp0LBB1PFxTpzdVeJ21gzVNQ6D4XGLTtdv4K4fOEYoeKEuzGoBaUDtIqz47gd
+5rwfQ3ps2slkxfbtQcdKEACKvsCwzqHlgwsxD8QNOFzXYLiiiJBX22fIRoiJeSDMKSZyuFtpykCm
+7bOpybPSHv3E7EIr8sIOr9MOe/R5HSthU2IgW1L5Ynr2t9HUnCA8CenkzIQjg0h5sruxcGWCYLx7
+q0f1AQs4Z7SebVbq1SCWVJNX/vc1bVjnjYfri7RX5WMmjJkuSnuIoP6a42cqJcAg7m0STB0elFAy
+oO4vW9/JEmFUqLyQmWnoLJHX3IKtWa9CPvE=
+=OA6b
+-----END PGP MESSAGE-----
+
+--------------EOdOT2kJUL5hgCilmIhYyVZg--