chore(release): prepare for 1.112.10

This caused too many problems after switching
the default setting for `show_emails`
from DC_SHOW_EMAILS_OFF to DC_SHOW_EMAILS_ALL
in <https://github.com/deltachat/deltachat-core-rust/pull/4019>

There is a topic <https://support.delta.chat/t/setting-no-chats-only-for-show-classic-e-mails-showing-classic-emails/2481>
on the forum with multiple requests to revert this setting
due to old emails being downloaded.

.github/workflows/ci.yml

@@ -16,11 +16,11 @@ env:
   RUSTFLAGS: -Dwarnings
 
 jobs:
-  lint_rust:
-    name: Lint Rust
+  lint:
+    name: Rustfmt and Clippy
     runs-on: ubuntu-latest
     env:
-      RUSTUP_TOOLCHAIN: 1.68.2
+      RUSTUP_TOOLCHAIN: 1.68.0
     steps:
       - uses: actions/checkout@v3
       - name: Install rustfmt and clippy
@@ -31,8 +31,6 @@ jobs:
         run: cargo fmt --all -- --check
       - name: Run clippy
         run: scripts/clippy.sh
-      - name: Check
-        run: cargo check --workspace --all-targets --all-features
 
   cargo_deny:
     name: cargo deny
@@ -66,28 +64,34 @@ jobs:
       - name: Rustdoc
         run: cargo doc --document-private-items --no-deps
 
-  rust_tests:
-    name: Rust tests
+  build_and_test:
+    name: Build and test
     strategy:
+      fail-fast: false
       matrix:
         include:
+          # Currently used Rust version.
           - os: ubuntu-latest
-            rust: 1.68.2
+            rust: 1.68.0
+            python: 3.9
           - os: windows-latest
-            rust: 1.68.2
+            rust: 1.68.0
+            python: false # Python bindings compilation on Windows is not supported.
           - os: macos-latest
-            rust: 1.68.2
+            rust: 1.68.0
+            python: 3.9
 
-          # Minimum Supported Rust Version = 1.65.0
+          # Minimum Supported Rust Version = 1.64.0
           #
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
           # built.
           - os: ubuntu-latest
-            rust: 1.65.0
+            rust: 1.64.0
+            python: 3.7
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@master
 
       - name: Install Rust ${{ matrix.rust }}
         run: rustup toolchain install --profile minimal ${{ matrix.rust }}
@@ -96,176 +100,64 @@ jobs:
       - name: Cache rust cargo artifacts
         uses: swatinem/rust-cache@v2
 
+      - name: Check
+        run: cargo check --workspace --bins --examples --tests --benches
+
       - name: Tests
         run: cargo test --workspace
 
       - name: Test cargo vendor
         run: cargo vendor
 
-  c_library:
-    name: Build C library
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-
-      - name: Build C library
-        run: cargo build -p deltachat_ffi --features jsonrpc
-
-      - name: Upload C library
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.os }}-libdeltachat.a
-          path: target/debug/libdeltachat.a
-          retention-days: 1
-
-  rpc_server:
-    name: Build deltachat-rpc-server
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Cache rust cargo artifacts
-        uses: swatinem/rust-cache@v2
-
-      - name: Build deltachat-rpc-server
-        run: cargo build -p deltachat-rpc-server
-
-      - name: Upload deltachat-rpc-server
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.os }}-deltachat-rpc-server
-          path: target/debug/deltachat-rpc-server
-          retention-days: 1
-
-  python_lint:
-    name: Python lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-
-      - name: Install tox
-        run: pip install tox
-
-      - name: Lint Python bindings
-        working-directory: python
-        run: tox -e lint
-
-      - name: Lint deltachat-rpc-client
-        working-directory: deltachat-rpc-client
-        run: tox -e lint
-
-  python_tests:
-    name: Python tests
-    needs: ["c_library", "python_lint"]
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          # Currently used Rust version.
-          - os: ubuntu-latest
-            python: 3.11
-          - os: macos-latest
-            python: 3.11
-
-          # PyPy tests
-          - os: ubuntu-latest
-            python: pypy3.9
-          - os: macos-latest
-            python: pypy3.9
-
-          # Minimum Supported Python Version = 3.7
-          # This is the minimum version for which manylinux Python wheels are
-          # built. Test it with minimum supported Rust version.
-          - os: ubuntu-latest
-            python: 3.7
-
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Download libdeltachat.a
-        uses: actions/download-artifact@v3
-        with:
-          name: ${{ matrix.os }}-libdeltachat.a
-          path: target/debug
-
       - name: Install python
+        if: ${{ matrix.python }}
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python }}
 
       - name: Install tox
+        if: ${{ matrix.python }}
         run: pip install tox
 
+      - name: Build C library
+        if: ${{ matrix.python }}
+        run: cargo build -p deltachat_ffi --features jsonrpc
+
       - name: Run python tests
+        if: ${{ matrix.python }}
         env:
           DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
           DCC_RS_TARGET: debug
           DCC_RS_DEV: ${{ github.workspace }}
         working-directory: python
-        run: tox -e mypy,doc,py
+        run: tox -e lint,mypy,doc,py3
 
-  aysnc_python_tests:
-    name: Async Python tests
-    needs: ["python_lint", "rpc_server"]
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          # Currently used Rust version.
-          - os: ubuntu-latest
-            python: 3.11
-          - os: macos-latest
-            python: 3.11
-
-          # PyPy tests
-          - os: ubuntu-latest
-            python: pypy3.9
-          - os: macos-latest
-            python: pypy3.9
-
-          # Minimum Supported Python Version = 3.7
-          # This is the minimum version for which manylinux Python wheels are
-          # built. Test it with minimum supported Rust version.
-          - os: ubuntu-latest
-            python: 3.7
-
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install python
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python }}
-
-      - name: Install tox
-        run: pip install tox
-
-      - name: Download deltachat-rpc-server
-        uses: actions/download-artifact@v3
-        with:
-          name: ${{ matrix.os }}-deltachat-rpc-server
-          path: target/debug
-
-      - name: Make deltachat-rpc-server executable
-        run: chmod +x target/debug/deltachat-rpc-server
+      - name: Build deltachat-rpc-server
+        if: ${{ matrix.python }}
+        run: cargo build -p deltachat-rpc-server
 
       - name: Add deltachat-rpc-server to path
+        if: ${{ matrix.python }}
         run: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH
 
       - name: Run deltachat-rpc-client tests
+        if: ${{ matrix.python }}
         env:
           DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
         working-directory: deltachat-rpc-client
-        run: tox -e py
+        run: tox -e py3,lint
+
+      - name: Install pypy
+        if: ${{ matrix.python }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: "pypy${{ matrix.python }}"
+
+      - name: Run pypy tests
+        if: ${{ matrix.python }}
+        env:
+          DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+          DCC_RS_TARGET: debug
+          DCC_RS_DEV: ${{ github.workspace }}
+        working-directory: python
+        run: tox -e pypy3

.github/workflows/deltachat-rpc-server.yml

@@ -15,7 +15,7 @@ jobs:
   # Build a version statically linked against musl libc
   # to avoid problems with glibc version incompatibility.
   build_linux:
-    name: Cross-compile deltachat-rpc-server for x86_64, i686, aarch64 and armv7 Linux
+    name: Cross-compile deltachat-rpc-server for x86_64, aarch64 and armv7 Linux
     runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v3
@@ -30,13 +30,6 @@ jobs:
           path: target/x86_64-unknown-linux-musl/release/deltachat-rpc-server
           if-no-files-found: error
 
-      - name: Upload i686 binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: deltachat-rpc-server-i686
-          path: target/i686-unknown-linux-musl/release/deltachat-rpc-server
-          if-no-files-found: error
-
       - name: Upload aarch64 binary
         uses: actions/upload-artifact@v3
         with:
@@ -97,7 +90,7 @@ jobs:
       - name: Compose dist/ directory
         run: |
           mkdir dist
-          for x in x86_64 i686 aarch64 armv7 win32.exe win64.exe; do
+          for x in x86_64 aarch64 armv7 win32.exe win64.exe; do
             mv "deltachat-rpc-server-$x"/* "dist/deltachat-rpc-server-$x"
           done
 

CHANGELOG.md

@@ -1,59 +1,22 @@
 # Changelog
 
-## Unreleased
-
-### Changes
-- BREAKING: jsonrpc:
-  - `get_chatlist_items_by_entries` now takes only chatids instead of `ChatListEntries`
-  - `get_chatlist_entries` now returns `Vec<u32>` of chatids instead of `ChatListEntries`
-- BREAKING: Remove Secure-Join-Fingerprint header from "vc-contact-confirm", "vg-member-added" messages.
-- BREAKING: Remove "vc-contact-confirm-received", "vg-member-added-received" messages from Securejoin protocol.
-
-
-## [1.114.0] - 2023-04-24
-
-### Changes
-- JSON-RPC: Use long polling instead of server-sent notifications to retrieve events.
-  This better corresponds to JSON-RPC 2.0 server-client distinction
-  and is expected to simplify writing new bindings
-  because dispatching events can be done on higher level.
-- JSON-RPC: TS: Client now has a mandatory argument whether you want to start listening for events.
+## [1.112.10] - 2023-06-01
 
 ### Fixes
-- JSON-RPC: do not print to stdout on failure to find an account.
 
+- Disable `fetch_existing_msgs` setting by default.
+- Update `h2` to fix RUSTSEC-2023-0034.
 
-## [1.113.0] - 2023-04-18
-
-### Added
-- New JSON-RPC API `can_send()`.
-- New `dc_get_next_msgs()` and `dc_wait_next_msgs()` C APIs.
-  New `get_next_msgs()` and `wait_next_msgs()` JSON-RPC API.
-  These APIs can be used by bots to get all unprocessed messages
-  in the order of their arrival and wait for them without relying on events.
-- New Python bindings API `Account.wait_next_incoming_message()`.
-- New Python bindings APIs `Message.is_from_self()` and `Message.is_from_device()`.
-
-### Changes
-- Increase MSRV to 1.65.0. #4236
-- Remove upper limit on the attachment size. #4253
-- Update rPGP to 0.10.1. #4236
-- Compress HTML emails stored in the `mime_headers` column of the database.
-- Strip BIDI characters in system messages, files, group names and contact names. #3479
-- Use release date instead of the provider database update date in `maybe_add_time_based_warnings()`.
-- Gracefully terminate `deltachat-rpc-server` on Ctrl+C (`SIGINT`), `SIGTERM` and EOF.
-- Async Python API `get_fresh_messages_in_arrival_order()` is deprecated
-  in favor of `get_next_msgs()` and `wait_next_msgs()`.
-- Remove metadata from avatars and JPEG images before sending. #4037
-- Recode PNG and other supported image formats to JPEG if they are > 500K in size. #4037
+## [1.112.9] - 2023-05-12
 
 ### Fixes
-- Don't let blocking be bypassed using groups. #4316
-- Show a warning if quota list is empty. #4261
-- Do not reset status on other devices when sending signed reaction messages. #3692
-- Update `accounts.toml` atomically.
-- Fix python bindings README documentation on installing the bindings from source.
-- Remove confusing log line "ignoring unsolicited response Recent(…)". #3934
+
+- Fetch at most 100 existing messages even if EXISTS was not received.
+- Delete `smtp` rows when message sending is cancelled.
+
+### Changes
+
+- Improve SMTP logging.
 
 ## [1.112.8] - 2023-04-20
 
@@ -272,6 +235,7 @@
 - Do not treat invalid email addresses as an exception #3942
 - Add timeouts to HTTP requests #3948
 
+
 ## 1.105.0
 
 ### Changes
@@ -357,6 +321,7 @@
 - Disable read timeout during IMAP IDLE #3826
 - Bots automatically accept mailing lists #3831
 
+
 ## 1.102.0
 
 ### Changes
@@ -2440,6 +2405,3 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.112.5]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.4...v1.112.5
 [1.112.6]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.5...v1.112.6
 [1.112.7]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.6...v1.112.7
-[1.112.8]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.7...v1.112.8
-[1.113.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.8...v1.113.0
-[1.114.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.113.0...v1.114.0

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "deltachat"
-version = "1.114.0"
+version = "1.112.10"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.65"
+rust-version = "1.64"
 
 [profile.dev]
 debug = 0
@@ -38,10 +38,10 @@ async-channel = "1.8.0"
 async-imap = { version = "0.8.0", default-features = false, features = ["runtime-tokio"] }
 async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
 async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
-async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
+async_zip = { version = "0.0.11", default-features = false, features = ["deflate", "fs"] }
 backtrace = "0.3"
 base64 = "0.21"
-brotli = "3.3"
+bitflags = "1.3"
 chrono = { version = "0.4", default-features=false, features = ["clock", "std"] }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch = "master" }
@@ -51,7 +51,7 @@ futures = "0.3"
 futures-lite = "1.12.0"
 hex = "0.4.0"
 humansize = "2"
-image = { version = "0.24.6", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
+image = { version = "0.24.5", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
 iroh = { version = "0.4.1", default-features = false }
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
@@ -64,14 +64,14 @@ num-traits = "0.2"
 once_cell = "1.17.0"
 percent-encoding = "2.2"
 parking_lot = "0.12"
-pgp = { version = "0.10", default-features = false }
+pgp = { version = "0.9", default-features = false }
 pretty_env_logger = { version = "0.4", optional = true }
 qrcodegen = "1.7.0"
-quick-xml = "0.28"
+quick-xml = "0.27"
 rand = "0.8"
 regex = "1.7"
-reqwest = { version = "0.11.16", features = ["json"] }
-rusqlite = { version = "0.29", features = ["sqlcipher"] }
+reqwest = { version = "0.11.14", features = ["json"] }
+rusqlite = { version = "0.28", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 sanitize-filename = "0.4"
 serde_json = "1.0"
@@ -102,7 +102,7 @@ log = "0.4"
 pretty_env_logger = "0.4"
 proptest = { version = "1", default-features = false, features = ["std"] }
 tempfile = "3"
-testdir = "0.7.3"
+testdir = "0.7.2"
 tokio = { version = "1", features = ["parking_lot", "rt-multi-thread", "macros"] }
 
 [workspace]

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.114.0"
+version = "1.112.10"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"

deltachat-ffi/deltachat.h

@@ -182,17 +182,12 @@ typedef struct _dc_event_emitter dc_accounts_event_emitter_t;
  * and check it in the event loop thread
  * every time before calling dc_get_next_event().
  * To terminate the event loop, main thread should:
- * 1. Notify background threads,
- *    such as event loop (blocking in dc_get_next_event())
- *    and message processing loop (blocking in dc_wait_next_msgs()),
- *    that they should terminate by atomically setting the
- *    boolean flag in the memory
- *    shared between the main thread and background loop threads.
+ * 1. Notify event loop that it should terminate by atomically setting the
+ *    boolean flag in the memory shared between the main thread and event loop.
  * 2. Call dc_stop_io() or dc_accounts_stop_io(), depending
  *    on whether a single account or account manager is used.
  *    Stopping I/O is guaranteed to emit at least one event
  *    and interrupt the event loop even if it was blocked on dc_get_next_event().
- *    Stopping I/O is guaranteed to interrupt a single dc_wait_next_msgs().
  * 3. Wait until the event loop thread notices the flag,
  *    exits the event loop and terminates.
  * 4. Call dc_context_unref() or dc_accounts_unref().
@@ -463,16 +458,6 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    Prevents adding the "Device messages" and "Saved messages" chats,
  *                    adds Auto-Submitted header to outgoing messages
  *                    and accepts contact requests automatically (calling dc_accept_chat() is not needed for bots).
- * - `last_msg_id` = database ID of the last message processed by the bot.
- *                   This ID and IDs below it are guaranteed not to be returned
- *                   by dc_get_next_msgs() and dc_wait_next_msgs().
- *                   The value is updated automatically
- *                   when dc_markseen_msgs() is called,
- *                   but the bot can also set it manually if it processed
- *                   the message but does not want to mark it as seen.
- *                   For most bots calling `dc_markseen_msgs()` is the
- *                   recommended way to update this value
- *                   even for self-sent messages.
  * - `fetch_existing_msgs` = 1=fetch most recent existing messages on configure (default),
  *                    0=do not fetch existing messages on configure.
  *                    In both cases, existing recipients are added to the contact database.
@@ -1359,56 +1344,6 @@ int             dc_estimate_deletion_cnt    (dc_context_t* context, int from_ser
 dc_array_t*     dc_get_fresh_msgs            (dc_context_t* context);
 
 
-/**
- * Returns the message IDs of all messages of any chat
- * with a database ID higher than `last_msg_id` config value.
- *
- * This function is intended for use by bots.
- * Self-sent messages, device messages,
- * messages from contact requests
- * and muted chats are included,
- * but messages from explicitly blocked contacts
- * and chats are ignored.
- *
- * This function may be called as a part of event loop
- * triggered by DC_EVENT_INCOMING_MSG if you are only interested
- * in the incoming messages.
- * Otherwise use a separate message processing loop
- * calling dc_wait_next_msgs() in a separate thread.
- *
- * @memberof dc_context_t
- * @param context The context object as returned from dc_context_new().
- * @return An array of message IDs, must be dc_array_unref()'d when no longer used.
- *     On errors, the list is empty. NULL is never returned.
- */
-dc_array_t*     dc_get_next_msgs             (dc_context_t* context);
-
-
-/**
- * Waits for notification of new messages
- * and returns an array of new message IDs.
- * See the documentation for dc_get_next_msgs()
- * for the details of return value.
- *
- * This function waits for internal notification of
- * a new message in the database and returns afterwards.
- * Notification is also sent when I/O is started
- * to allow processing new messages
- * and when I/O is stopped using dc_stop_io() or dc_accounts_stop_io()
- * to allow for manual interruption of the message processing loop.
- * The function may return an empty array if there are
- * no messages after notification,
- * which may happen on start or if the message is quickly deleted
- * after adding it to the database.
- *
- * @memberof dc_context_t
- * @param context The context object as returned from dc_context_new().
- * @return An array of message IDs, must be dc_array_unref()'d when no longer used.
- *     On errors, the list is empty. NULL is never returned.
- */
-dc_array_t*     dc_wait_next_msgs            (dc_context_t* context);
-
-
 /**
  * Mark all messages in a chat as _noticed_.
  * _Noticed_ messages are no longer _fresh_ and do not count as being unseen
@@ -2008,11 +1943,6 @@ int             dc_resend_msgs               (dc_context_t* context, const uint3
  * Moreover, timer is started for incoming ephemeral messages.
  * This also happens for contact requests chats.
  *
- * This function updates last_msg_id configuration value
- * to the maximum of the current value and IDs passed to this function.
- * Bots which mark messages as seen can rely on this side effect
- * to avoid updating last_msg_id value manually.
- *
  * One #DC_EVENT_MSGS_NOTICED event is emitted per modified chat.
  *
  * @memberof dc_context_t

deltachat-ffi/src/lib.rs

@@ -161,8 +161,7 @@ pub unsafe extern "C" fn dc_context_open(
     let ctx = &*context;
     let passphrase = to_string_lossy(passphrase);
     block_on(ctx.open(passphrase))
-        .context("dc_context_open() failed")
-        .log_err(ctx)
+        .log_err(ctx, "dc_context_open() failed")
         .map(|b| b as libc::c_int)
         .unwrap_or(0)
 }
@@ -218,18 +217,16 @@ pub unsafe extern "C" fn dc_set_config(
         if key.starts_with("ui.") {
             ctx.set_ui_config(&key, value.as_deref())
                 .await
-                .with_context(|| format!("dc_set_config failed: Can't set {key} to {value:?}"))
-                .log_err(ctx)
+                .with_context(|| format!("Can't set {key} to {value:?}"))
+                .log_err(ctx, "dc_set_config() failed")
                 .is_ok() as libc::c_int
         } else {
             match config::Config::from_str(&key) {
                 Ok(key) => ctx
                     .set_config(key, value.as_deref())
                     .await
-                    .with_context(|| {
-                        format!("dc_set_config() failed: Can't set {key} to {value:?}")
-                    })
-                    .log_err(ctx)
+                    .with_context(|| format!("Can't set {key} to {value:?}"))
+                    .log_err(ctx, "dc_set_config() failed")
                     .is_ok() as libc::c_int,
                 Err(_) => {
                     warn!(ctx, "dc_set_config(): invalid key");
@@ -257,8 +254,7 @@ pub unsafe extern "C" fn dc_get_config(
         if key.starts_with("ui.") {
             ctx.get_ui_config(&key)
                 .await
-                .context("Can't get ui-config")
-                .log_err(ctx)
+                .log_err(ctx, "Can't get ui-config")
                 .unwrap_or_default()
                 .unwrap_or_default()
                 .strdup()
@@ -267,8 +263,7 @@ pub unsafe extern "C" fn dc_get_config(
                 Ok(key) => ctx
                     .get_config(key)
                     .await
-                    .context("Can't get config")
-                    .log_err(ctx)
+                    .log_err(ctx, "Can't get config")
                     .unwrap_or_default()
                     .unwrap_or_default()
                     .strdup(),
@@ -420,8 +415,7 @@ pub unsafe extern "C" fn dc_get_oauth2_url(
     block_on(async move {
         match oauth2::get_oauth2_url(ctx, &addr, &redirect)
             .await
-            .context("dc_get_oauth2_url failed")
-            .log_err(ctx)
+            .log_err(ctx, "dc_get_oauth2_url failed")
         {
             Ok(Some(res)) => res.strdup(),
             Ok(None) | Err(_) => ptr::null_mut(),
@@ -430,12 +424,7 @@ pub unsafe extern "C" fn dc_get_oauth2_url(
 }
 
 fn spawn_configure(ctx: Context) {
-    spawn(async move {
-        ctx.configure()
-            .await
-            .context("Configure failed")
-            .log_err(&ctx)
-    });
+    spawn(async move { ctx.configure().await.log_err(&ctx, "Configure failed") });
 }
 
 #[no_mangle]
@@ -460,8 +449,7 @@ pub unsafe extern "C" fn dc_is_configured(context: *mut dc_context_t) -> libc::c
     block_on(async move {
         ctx.is_configured()
             .await
-            .context("failed to get configured state")
-            .log_err(ctx)
+            .log_err(ctx, "failed to get configured state")
             .unwrap_or_default() as libc::c_int
     })
 }
@@ -803,8 +791,7 @@ pub unsafe extern "C" fn dc_preconfigure_keypair(
         key::store_self_keypair(ctx, &keypair, key::KeyPairUse::Default).await?;
         Ok::<_, anyhow::Error>(1)
     })
-    .context("Failed to save keypair")
-    .log_err(ctx)
+    .log_err(ctx, "Failed to save keypair")
     .unwrap_or(0)
 }
 
@@ -831,8 +818,7 @@ pub unsafe extern "C" fn dc_get_chatlist(
     block_on(async move {
         match chatlist::Chatlist::try_load(ctx, flags as usize, qs.as_deref(), qi)
             .await
-            .context("Failed to get chatlist")
-            .log_err(ctx)
+            .log_err(ctx, "Failed to get chatlist")
         {
             Ok(list) => {
                 let ffi_list = ChatlistWrapper { context, list };
@@ -857,8 +843,7 @@ pub unsafe extern "C" fn dc_create_chat_by_contact_id(
     block_on(async move {
         ChatId::create_for_contact(ctx, ContactId::new(contact_id))
             .await
-            .context("Failed to create chat from contact_id")
-            .log_err(ctx)
+            .log_err(ctx, "Failed to create chat from contact_id")
             .map(|id| id.to_u32())
             .unwrap_or(0)
     })
@@ -878,8 +863,7 @@ pub unsafe extern "C" fn dc_get_chat_id_by_contact_id(
     block_on(async move {
         ChatId::lookup_by_contact(ctx, ContactId::new(contact_id))
             .await
-            .context("Failed to get chat for contact_id")
-            .log_err(ctx)
+            .log_err(ctx, "Failed to get chat for contact_id")
             .unwrap_or_default() // unwraps the Result
             .map(|id| id.to_u32())
             .unwrap_or(0) // unwraps the Option
@@ -1021,8 +1005,7 @@ pub unsafe extern "C" fn dc_get_msg_reactions(
     let ctx = &*context;
 
     let reactions = if let Ok(reactions) = block_on(get_msg_reactions(ctx, MsgId::new(msg_id)))
-        .context("failed dc_get_msg_reactions() call")
-        .log_err(ctx)
+        .log_err(ctx, "failed dc_get_msg_reactions() call")
     {
         reactions
     } else {
@@ -1050,8 +1033,7 @@ pub unsafe extern "C" fn dc_send_webxdc_status_update(
         &to_string_lossy(json),
         &to_string_lossy(descr),
     ))
-    .context("Failed to send webxdc update")
-    .log_err(ctx)
+    .log_err(ctx, "Failed to send webxdc update")
     .is_ok() as libc::c_int
 }
 
@@ -1270,8 +1252,7 @@ pub unsafe extern "C" fn dc_get_fresh_msgs(
         let arr = dc_array_t::from(
             ctx.get_fresh_msgs()
                 .await
-                .context("Failed to get fresh messages")
-                .log_err(ctx)
+                .log_err(ctx, "Failed to get fresh messages")
                 .unwrap_or_default()
                 .iter()
                 .map(|msg_id| msg_id.to_u32())
@@ -1281,50 +1262,6 @@ pub unsafe extern "C" fn dc_get_fresh_msgs(
     })
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn dc_get_next_msgs(context: *mut dc_context_t) -> *mut dc_array::dc_array_t {
-    if context.is_null() {
-        eprintln!("ignoring careless call to dc_get_next_msgs()");
-        return ptr::null_mut();
-    }
-    let ctx = &*context;
-
-    let msg_ids = block_on(ctx.get_next_msgs())
-        .context("failed to get next messages")
-        .log_err(ctx)
-        .unwrap_or_default();
-    let arr = dc_array_t::from(
-        msg_ids
-            .iter()
-            .map(|msg_id| msg_id.to_u32())
-            .collect::<Vec<u32>>(),
-    );
-    Box::into_raw(Box::new(arr))
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn dc_wait_next_msgs(
-    context: *mut dc_context_t,
-) -> *mut dc_array::dc_array_t {
-    if context.is_null() {
-        eprintln!("ignoring careless call to dc_wait_next_msgs()");
-        return ptr::null_mut();
-    }
-    let ctx = &*context;
-
-    let msg_ids = block_on(ctx.wait_next_msgs())
-        .context("failed to wait for next messages")
-        .log_err(ctx)
-        .unwrap_or_default();
-    let arr = dc_array_t::from(
-        msg_ids
-            .iter()
-            .map(|msg_id| msg_id.to_u32())
-            .collect::<Vec<u32>>(),
-    );
-    Box::into_raw(Box::new(arr))
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_marknoticed_chat(context: *mut dc_context_t, chat_id: u32) {
     if context.is_null() {
@@ -1336,8 +1273,7 @@ pub unsafe extern "C" fn dc_marknoticed_chat(context: *mut dc_context_t, chat_id
     block_on(async move {
         chat::marknoticed_chat(ctx, ChatId::new(chat_id))
             .await
-            .context("Failed marknoticed chat")
-            .log_err(ctx)
+            .log_err(ctx, "Failed marknoticed chat")
             .unwrap_or(())
     })
 }
@@ -1479,8 +1415,7 @@ pub unsafe extern "C" fn dc_set_chat_visibility(
         ChatId::new(chat_id)
             .set_visibility(ctx, visibility)
             .await
-            .context("Failed setting chat visibility")
-            .log_err(ctx)
+            .log_err(ctx, "Failed setting chat visibility")
             .unwrap_or(())
     })
 }
@@ -1497,9 +1432,7 @@ pub unsafe extern "C" fn dc_delete_chat(context: *mut dc_context_t, chat_id: u32
         ChatId::new(chat_id)
             .delete(ctx)
             .await
-            .context("Failed chat delete")
-            .log_err(ctx)
-            .ok();
+            .ok_or_log_msg(ctx, "Failed chat delete");
     })
 }
 
@@ -1515,9 +1448,7 @@ pub unsafe extern "C" fn dc_block_chat(context: *mut dc_context_t, chat_id: u32)
         ChatId::new(chat_id)
             .block(ctx)
             .await
-            .context("Failed chat block")
-            .log_err(ctx)
-            .ok();
+            .ok_or_log_msg(ctx, "Failed chat block");
     })
 }
 
@@ -1533,9 +1464,7 @@ pub unsafe extern "C" fn dc_accept_chat(context: *mut dc_context_t, chat_id: u32
         ChatId::new(chat_id)
             .accept(ctx)
             .await
-            .context("Failed chat accept")
-            .log_err(ctx)
-            .ok();
+            .ok_or_log_msg(ctx, "Failed chat accept");
     })
 }
 
@@ -1633,8 +1562,7 @@ pub unsafe extern "C" fn dc_create_group_chat(
     block_on(async move {
         chat::create_group_chat(ctx, protect, &to_string_lossy(name))
             .await
-            .context("Failed to create group chat")
-            .log_err(ctx)
+            .log_err(ctx, "Failed to create group chat")
             .map(|id| id.to_u32())
             .unwrap_or(0)
     })
@@ -1648,8 +1576,7 @@ pub unsafe extern "C" fn dc_create_broadcast_list(context: *mut dc_context_t) ->
     }
     let ctx = &*context;
     block_on(chat::create_broadcast_list(ctx))
-        .context("Failed to create broadcast list")
-        .log_err(ctx)
+        .log_err(ctx, "Failed to create broadcast list")
         .map(|id| id.to_u32())
         .unwrap_or(0)
 }
@@ -1671,8 +1598,7 @@ pub unsafe extern "C" fn dc_is_contact_in_chat(
         ChatId::new(chat_id),
         ContactId::new(contact_id),
     ))
-    .context("is_contact_in_chat failed")
-    .log_err(ctx)
+    .log_err(ctx, "is_contact_in_chat failed")
     .unwrap_or_default() as libc::c_int
 }
 
@@ -1693,8 +1619,7 @@ pub unsafe extern "C" fn dc_add_contact_to_chat(
         ChatId::new(chat_id),
         ContactId::new(contact_id),
     ))
-    .context("Failed to add contact")
-    .log_err(ctx)
+    .log_err(ctx, "Failed to add contact")
     .is_ok() as libc::c_int
 }
 
@@ -1715,8 +1640,7 @@ pub unsafe extern "C" fn dc_remove_contact_from_chat(
         ChatId::new(chat_id),
         ContactId::new(contact_id),
     ))
-    .context("Failed to remove contact")
-    .log_err(ctx)
+    .log_err(ctx, "Failed to remove contact")
     .is_ok() as libc::c_int
 }
 
@@ -1835,8 +1759,7 @@ pub unsafe extern "C" fn dc_get_chat_ephemeral_timer(
     // ignored when ephemeral timer value is used to construct
     // message headers.
     block_on(async move { ChatId::new(chat_id).get_ephemeral_timer(ctx).await })
-        .context("Failed to get ephemeral timer")
-        .log_err(ctx)
+        .log_err(ctx, "Failed to get ephemeral timer")
         .unwrap_or_default()
         .to_u32()
 }
@@ -1857,8 +1780,7 @@ pub unsafe extern "C" fn dc_set_chat_ephemeral_timer(
         ChatId::new(chat_id)
             .set_ephemeral_timer(ctx, EphemeralTimer::from_u32(timer))
             .await
-            .context("Failed to set ephemeral timer")
-            .log_err(ctx)
+            .log_err(ctx, "Failed to set ephemeral timer")
             .is_ok() as libc::c_int
     })
 }
@@ -1934,8 +1856,7 @@ pub unsafe extern "C" fn dc_delete_msgs(
     let msg_ids = convert_and_prune_message_ids(msg_ids, msg_cnt);
 
     block_on(message::delete_msgs(ctx, &msg_ids))
-        .context("failed dc_delete_msgs() call")
-        .log_err(ctx)
+        .log_err(ctx, "failed dc_delete_msgs() call")
         .ok();
 }
 
@@ -1999,8 +1920,7 @@ pub unsafe extern "C" fn dc_markseen_msgs(
     let ctx = &*context;
 
     block_on(message::markseen_msgs(ctx, msg_ids))
-        .context("failed dc_markseen_msgs() call")
-        .log_err(ctx)
+        .log_err(ctx, "failed dc_markseen_msgs() call")
         .ok();
 }
 
@@ -2042,8 +1962,7 @@ pub unsafe extern "C" fn dc_download_full_msg(context: *mut dc_context_t, msg_id
     }
     let ctx = &*context;
     block_on(MsgId::new(msg_id).download_full(ctx))
-        .context("Failed to download message fully.")
-        .log_err(ctx)
+        .log_err(ctx, "Failed to download message fully.")
         .ok();
 }
 
@@ -2091,8 +2010,7 @@ pub unsafe extern "C" fn dc_create_contact(
     let name = to_string_lossy(name);
 
     block_on(Contact::create(ctx, &name, &to_string_lossy(addr)))
-        .context("Cannot create contact")
-        .log_err(ctx)
+        .log_err(ctx, "Cannot create contact")
         .map(|id| id.to_u32())
         .unwrap_or(0)
 }
@@ -2169,8 +2087,7 @@ pub unsafe extern "C" fn dc_get_blocked_contacts(
         Box::into_raw(Box::new(dc_array_t::from(
             Contact::get_all_blocked(ctx)
                 .await
-                .context("Can't get blocked contacts")
-                .log_err(ctx)
+                .log_err(ctx, "Can't get blocked contacts")
                 .unwrap_or_default()
                 .iter()
                 .map(|id| id.to_u32())
@@ -2195,15 +2112,11 @@ pub unsafe extern "C" fn dc_block_contact(
         if block == 0 {
             Contact::unblock(ctx, contact_id)
                 .await
-                .context("Can't unblock contact")
-                .log_err(ctx)
-                .ok();
+                .ok_or_log_msg(ctx, "Can't unblock contact");
         } else {
             Contact::block(ctx, contact_id)
                 .await
-                .context("Can't block contact")
-                .log_err(ctx)
-                .ok();
+                .ok_or_log_msg(ctx, "Can't block contact");
         }
     });
 }
@@ -2276,8 +2189,7 @@ fn spawn_imex(ctx: Context, what: imex::ImexMode, param1: String, passphrase: Op
     spawn(async move {
         imex::imex(&ctx, what, param1.as_ref(), passphrase)
             .await
-            .context("IMEX failed")
-            .log_err(&ctx)
+            .log_err(&ctx, "IMEX failed")
     });
 }
 
@@ -2463,8 +2375,7 @@ pub unsafe extern "C" fn dc_join_securejoin(
         securejoin::join_securejoin(ctx, &to_string_lossy(qr))
             .await
             .map(|chatid| chatid.to_u32())
-            .context("failed dc_join_securejoin() call")
-            .log_err(ctx)
+            .log_err(ctx, "failed dc_join_securejoin() call")
             .unwrap_or_default()
     })
 }
@@ -2486,8 +2397,7 @@ pub unsafe extern "C" fn dc_send_locations_to_chat(
         ChatId::new(chat_id),
         seconds as i64,
     ))
-    .context("Failed dc_send_locations_to_chat()")
-    .log_err(ctx)
+    .log_err(ctx, "Failed dc_send_locations_to_chat()")
     .ok();
 }
 
@@ -2570,8 +2480,7 @@ pub unsafe extern "C" fn dc_delete_all_locations(context: *mut dc_context_t) {
     block_on(async move {
         location::delete_all(ctx)
             .await
-            .context("Failed to delete locations")
-            .log_err(ctx)
+            .log_err(ctx, "Failed to delete locations")
             .ok()
     });
 }
@@ -2855,8 +2764,7 @@ pub unsafe extern "C" fn dc_chatlist_get_summary(
             .list
             .get_summary(ctx, index, maybe_chat)
             .await
-            .context("get_summary failed")
-            .log_err(ctx)
+            .log_err(ctx, "get_summary failed")
             .unwrap_or_default();
         Box::into_raw(Box::new(summary.into()))
     })
@@ -2884,8 +2792,7 @@ pub unsafe extern "C" fn dc_chatlist_get_summary2(
         msg_id,
         None,
     ))
-    .context("get_summary2 failed")
-    .log_err(ctx)
+    .log_err(ctx, "get_summary2 failed")
     .unwrap_or_default();
     Box::into_raw(Box::new(summary.into()))
 }
@@ -3068,8 +2975,7 @@ pub unsafe extern "C" fn dc_chat_can_send(chat: *mut dc_chat_t) -> libc::c_int {
     let ffi_chat = &*chat;
     let ctx = &*ffi_chat.context;
     block_on(ffi_chat.chat.can_send(ctx))
-        .context("can_send failed")
-        .log_err(ctx)
+        .log_err(ctx, "can_send failed")
         .unwrap_or_default() as libc::c_int
 }
 
@@ -3514,8 +3420,7 @@ pub unsafe extern "C" fn dc_msg_get_summary(
     let ctx = &*ffi_msg.context;
 
     let summary = block_on(ffi_msg.message.get_summary(ctx, maybe_chat))
-        .context("dc_msg_get_summary failed")
-        .log_err(ctx)
+        .log_err(ctx, "dc_msg_get_summary failed")
         .unwrap_or_default();
     Box::into_raw(Box::new(summary.into()))
 }
@@ -3533,8 +3438,7 @@ pub unsafe extern "C" fn dc_msg_get_summarytext(
     let ctx = &*ffi_msg.context;
 
     let summary = block_on(ffi_msg.message.get_summary(ctx, None))
-        .context("dc_msg_get_summarytext failed")
-        .log_err(ctx)
+        .log_err(ctx, "dc_msg_get_summarytext failed")
         .unwrap_or_default();
     match usize::try_from(approx_characters) {
         Ok(chars) => summary.truncated_text(chars).strdup(),
@@ -3801,9 +3705,7 @@ pub unsafe extern "C" fn dc_msg_latefiling_mediasize(
             .message
             .latefiling_mediasize(ctx, width, height, duration)
     })
-    .context("Cannot set media size")
-    .log_err(ctx)
-    .ok();
+    .ok_or_log_msg(ctx, "Cannot set media size");
 }
 
 #[no_mangle]
@@ -3842,8 +3744,7 @@ pub unsafe extern "C" fn dc_msg_set_quote(msg: *mut dc_msg_t, quote: *const dc_m
             .message
             .set_quote(&*ffi_msg.context, quote_msg)
             .await
-            .context("failed to set quote")
-            .log_err(&*ffi_msg.context)
+            .log_err(&*ffi_msg.context, "failed to set quote")
             .ok();
     });
 }
@@ -3874,8 +3775,7 @@ pub unsafe extern "C" fn dc_msg_get_quoted_msg(msg: *const dc_msg_t) -> *mut dc_
             .message
             .quoted_message(context)
             .await
-            .context("failed to get quoted message")
-            .log_err(context)
+            .log_err(context, "failed to get quoted message")
             .unwrap_or(None)
     });
 
@@ -3898,8 +3798,7 @@ pub unsafe extern "C" fn dc_msg_get_parent(msg: *const dc_msg_t) -> *mut dc_msg_
             .message
             .parent(context)
             .await
-            .context("failed to get parent message")
-            .log_err(context)
+            .log_err(context, "failed to get parent message")
             .unwrap_or(None)
     });
 
@@ -4090,8 +3989,7 @@ pub unsafe extern "C" fn dc_contact_is_verified(contact: *mut dc_contact_t) -> l
     let ctx = &*ffi_contact.context;
 
     block_on(ffi_contact.contact.is_verified(ctx))
-        .context("is_verified failed")
-        .log_err(ctx)
+        .log_err(ctx, "is_verified failed")
         .unwrap_or_default() as libc::c_int
 }
 
@@ -4106,8 +4004,7 @@ pub unsafe extern "C" fn dc_contact_get_verifier_addr(
     let ffi_contact = &*contact;
     let ctx = &*ffi_contact.context;
     block_on(ffi_contact.contact.get_verifier_addr(ctx))
-        .context("failed to get verifier for contact")
-        .log_err(ctx)
+        .log_err(ctx, "failed to get verifier for contact")
         .unwrap_or_default()
         .strdup()
 }
@@ -4121,8 +4018,7 @@ pub unsafe extern "C" fn dc_contact_get_verifier_id(contact: *mut dc_contact_t)
     let ffi_contact = &*contact;
     let ctx = &*ffi_contact.context;
     let verifier_contact_id = block_on(ffi_contact.contact.get_verifier_id(ctx))
-        .context("failed to get verifier")
-        .log_err(ctx)
+        .log_err(ctx, "failed to get verifier")
         .unwrap_or_default()
         .unwrap_or_default();
 
@@ -4274,8 +4170,8 @@ pub unsafe extern "C" fn dc_backup_provider_new(
             provider,
         })
         .map(|ffi_provider| Box::into_raw(Box::new(ffi_provider)))
+        .log_err(ctx, "BackupProvider failed")
         .context("BackupProvider failed")
-        .log_err(ctx)
         .set_last_error(ctx)
         .unwrap_or(ptr::null_mut())
 }
@@ -4291,8 +4187,8 @@ pub unsafe extern "C" fn dc_backup_provider_get_qr(
     let ffi_provider = &*provider;
     let ctx = &*ffi_provider.context;
     deltachat::qr::format_backup(&ffi_provider.provider.qr())
+        .log_err(ctx, "BackupProvider get_qr failed")
         .context("BackupProvider get_qr failed")
-        .log_err(ctx)
         .set_last_error(ctx)
         .unwrap_or_default()
         .strdup()
@@ -4310,8 +4206,8 @@ pub unsafe extern "C" fn dc_backup_provider_get_qr_svg(
     let ctx = &*ffi_provider.context;
     let provider = &ffi_provider.provider;
     block_on(generate_backup_qr(ctx, &provider.qr()))
+        .log_err(ctx, "BackupProvider get_qr_svg failed")
         .context("BackupProvider get_qr_svg failed")
-        .log_err(ctx)
         .set_last_error(ctx)
         .unwrap_or_default()
         .strdup()
@@ -4327,8 +4223,8 @@ pub unsafe extern "C" fn dc_backup_provider_wait(provider: *mut dc_backup_provid
     let ctx = &*ffi_provider.context;
     let provider = &mut ffi_provider.provider;
     block_on(provider)
+        .log_err(ctx, "Failed to await BackupProvider")
         .context("Failed to await BackupProvider")
-        .log_err(ctx)
         .set_last_error(ctx)
         .ok();
 }
@@ -4360,16 +4256,16 @@ pub unsafe extern "C" fn dc_receive_backup(
 // user from deallocating it by calling unref on the object while we are using it.
 fn receive_backup(ctx: Context, qr_text: String) -> libc::c_int {
     let qr = match block_on(qr::check_qr(&ctx, &qr_text))
+        .log_err(&ctx, "Invalid QR code")
         .context("Invalid QR code")
-        .log_err(&ctx)
         .set_last_error(&ctx)
     {
         Ok(qr) => qr,
         Err(_) => return 0,
     };
     match block_on(imex::get_backup(&ctx, qr))
+        .log_err(&ctx, "Get backup failed")
         .context("Get backup failed")
-        .log_err(&ctx)
         .set_last_error(&ctx)
     {
         Ok(_) => 1,
@@ -4421,8 +4317,8 @@ where
     ///
     /// ```no_compile
     /// some_dc_rust_api_call_returning_result()
+    ///     .log_err(&context, "My API call failed")
     ///     .context("My API call failed")
-    ///     .log_err(&context)
     ///     .set_last_error(&context)
     ///     .unwrap_or_default()
     /// ```
@@ -4509,8 +4405,7 @@ pub unsafe extern "C" fn dc_provider_new_from_email_with_dns(
     let socks5_enabled = block_on(async move {
         ctx.get_config_bool(config::Config::Socks5Enabled)
             .await
-            .context("Can't get config")
-            .log_err(ctx)
+            .log_err(ctx, "Can't get config")
     });
 
     match socks5_enabled {
@@ -4589,10 +4484,7 @@ pub unsafe extern "C" fn dc_get_http_response(
 
     let context = &*context;
     let url = to_string_lossy(url);
-    if let Ok(response) = block_on(read_url_blob(context, &url))
-        .context("read_url_blob")
-        .log_err(context)
-    {
+    if let Ok(response) = block_on(read_url_blob(context, &url)).log_err(context, "read_url_blob") {
         Box::into_raw(Box::new(response))
     } else {
         ptr::null_mut()
@@ -4967,6 +4859,7 @@ pub unsafe extern "C" fn dc_accounts_get_event_emitter(
 #[cfg(feature = "jsonrpc")]
 mod jsonrpc {
     use deltachat_jsonrpc::api::CommandApi;
+    use deltachat_jsonrpc::events::event_to_json_rpc_notification;
     use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcSession};
 
     use super::*;
@@ -4974,6 +4867,7 @@ mod jsonrpc {
     pub struct dc_jsonrpc_instance_t {
         receiver: OutReceiver,
         handle: RpcSession<CommandApi>,
+        event_thread: JoinHandle<Result<(), anyhow::Error>>,
     }
 
     #[no_mangle]
@@ -4986,12 +4880,28 @@ mod jsonrpc {
         }
 
         let account_manager = &*account_manager;
+        let events = block_on(account_manager.read()).get_event_emitter();
         let cmd_api = deltachat_jsonrpc::api::CommandApi::from_arc(account_manager.inner.clone());
 
         let (request_handle, receiver) = RpcClient::new();
-        let handle = RpcSession::new(request_handle, cmd_api);
+        let handle = RpcSession::new(request_handle.clone(), cmd_api);
 
-        let instance = dc_jsonrpc_instance_t { receiver, handle };
+        let event_thread = spawn(async move {
+            while let Some(event) = events.recv().await {
+                let event = event_to_json_rpc_notification(event);
+                request_handle
+                    .send_notification("event", Some(event))
+                    .await?;
+            }
+            let res: Result<(), anyhow::Error> = Ok(());
+            res
+        });
+
+        let instance = dc_jsonrpc_instance_t {
+            receiver,
+            handle,
+            event_thread,
+        };
 
         Box::into_raw(Box::new(instance))
     }
@@ -5002,6 +4912,7 @@ mod jsonrpc {
             eprintln!("ignoring careless call to dc_jsonrpc_unref()");
             return;
         }
+        (*jsonrpc_instance).event_thread.abort();
         drop(Box::from_raw(jsonrpc_instance));
     }
 

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.114.0"
+version = "1.112.10"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
@@ -19,21 +19,21 @@ serde = { version = "1.0", features = ["derive"] }
 tempfile = "3.3.0"
 log = "0.4"
 async-channel = { version = "1.8.0" }
-futures = { version = "0.3.28" }
-serde_json = "1.0.95"
+futures = { version = "0.3.26" }
+serde_json = "1.0.91"
 yerpc = { version = "0.4.3", features = ["anyhow_expose"] }
 typescript-type-def = { version = "0.5.5", features = ["json_value"] }
-tokio = { version = "1.27.0" }
+tokio = { version = "1.25.0" }
 sanitize-filename = "0.4"
-walkdir = "2.3.3"
+walkdir = "2.3.2"
 base64 = "0.21"
 
 # optional dependencies
-axum = { version = "0.6.12", optional = true, features = ["ws"] }
+axum = { version = "0.6.11", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.27.0", features = ["full", "rt-multi-thread"] }
+tokio = { version = "1.25.0", features = ["full", "rt-multi-thread"] }
 
 
 [features]

deltachat-jsonrpc/src/api/events.rs

@@ -1,28 +1,19 @@
-use deltachat::{Event as CoreEvent, EventType as CoreEventType};
+use deltachat::{Event, EventType};
 use serde::Serialize;
+use serde_json::{json, Value};
 use typescript_type_def::TypeDef;
 
-#[derive(Serialize, TypeDef)]
-pub struct Event {
-    /// Event payload.
-    event: EventType,
-
-    /// Account ID.
-    context_id: u32,
-}
-
-impl From<CoreEvent> for Event {
-    fn from(event: CoreEvent) -> Self {
-        Event {
-            event: event.typ.into(),
-            context_id: event.id,
-        }
-    }
+pub fn event_to_json_rpc_notification(event: Event) -> Value {
+    let id: JSONRPCEventType = event.typ.into();
+    json!({
+        "event": id,
+        "contextId": event.id,
+    })
 }
 
 #[derive(Serialize, TypeDef)]
-#[serde(tag = "type")]
-pub enum EventType {
+#[serde(tag = "type", rename = "Event")]
+pub enum JSONRPCEventType {
     /// The library-user may write an informational string to the log.
     ///
     /// This event should *not* be reported to the end-user using a popup or something like
@@ -295,27 +286,27 @@ pub enum EventType {
     },
 }
 
-impl From<CoreEventType> for EventType {
-    fn from(event: CoreEventType) -> Self {
-        use EventType::*;
+impl From<EventType> for JSONRPCEventType {
+    fn from(event: EventType) -> Self {
+        use JSONRPCEventType::*;
         match event {
-            CoreEventType::Info(msg) => Info { msg },
-            CoreEventType::SmtpConnected(msg) => SmtpConnected { msg },
-            CoreEventType::ImapConnected(msg) => ImapConnected { msg },
-            CoreEventType::SmtpMessageSent(msg) => SmtpMessageSent { msg },
-            CoreEventType::ImapMessageDeleted(msg) => ImapMessageDeleted { msg },
-            CoreEventType::ImapMessageMoved(msg) => ImapMessageMoved { msg },
-            CoreEventType::ImapInboxIdle => ImapInboxIdle,
-            CoreEventType::NewBlobFile(file) => NewBlobFile { file },
-            CoreEventType::DeletedBlobFile(file) => DeletedBlobFile { file },
-            CoreEventType::Warning(msg) => Warning { msg },
-            CoreEventType::Error(msg) => Error { msg },
-            CoreEventType::ErrorSelfNotInGroup(msg) => ErrorSelfNotInGroup { msg },
-            CoreEventType::MsgsChanged { chat_id, msg_id } => MsgsChanged {
+            EventType::Info(msg) => Info { msg },
+            EventType::SmtpConnected(msg) => SmtpConnected { msg },
+            EventType::ImapConnected(msg) => ImapConnected { msg },
+            EventType::SmtpMessageSent(msg) => SmtpMessageSent { msg },
+            EventType::ImapMessageDeleted(msg) => ImapMessageDeleted { msg },
+            EventType::ImapMessageMoved(msg) => ImapMessageMoved { msg },
+            EventType::ImapInboxIdle => ImapInboxIdle,
+            EventType::NewBlobFile(file) => NewBlobFile { file },
+            EventType::DeletedBlobFile(file) => DeletedBlobFile { file },
+            EventType::Warning(msg) => Warning { msg },
+            EventType::Error(msg) => Error { msg },
+            EventType::ErrorSelfNotInGroup(msg) => ErrorSelfNotInGroup { msg },
+            EventType::MsgsChanged { chat_id, msg_id } => MsgsChanged {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::ReactionsChanged {
+            EventType::ReactionsChanged {
                 chat_id,
                 msg_id,
                 contact_id,
@@ -324,76 +315,92 @@ impl From<CoreEventType> for EventType {
                 msg_id: msg_id.to_u32(),
                 contact_id: contact_id.to_u32(),
             },
-            CoreEventType::IncomingMsg { chat_id, msg_id } => IncomingMsg {
+            EventType::IncomingMsg { chat_id, msg_id } => IncomingMsg {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::IncomingMsgBunch { msg_ids } => IncomingMsgBunch {
+            EventType::IncomingMsgBunch { msg_ids } => IncomingMsgBunch {
                 msg_ids: msg_ids.into_iter().map(|id| id.to_u32()).collect(),
             },
-            CoreEventType::MsgsNoticed(chat_id) => MsgsNoticed {
+            EventType::MsgsNoticed(chat_id) => MsgsNoticed {
                 chat_id: chat_id.to_u32(),
             },
-            CoreEventType::MsgDelivered { chat_id, msg_id } => MsgDelivered {
+            EventType::MsgDelivered { chat_id, msg_id } => MsgDelivered {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::MsgFailed { chat_id, msg_id } => MsgFailed {
+            EventType::MsgFailed { chat_id, msg_id } => MsgFailed {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::MsgRead { chat_id, msg_id } => MsgRead {
+            EventType::MsgRead { chat_id, msg_id } => MsgRead {
                 chat_id: chat_id.to_u32(),
                 msg_id: msg_id.to_u32(),
             },
-            CoreEventType::ChatModified(chat_id) => ChatModified {
+            EventType::ChatModified(chat_id) => ChatModified {
                 chat_id: chat_id.to_u32(),
             },
-            CoreEventType::ChatEphemeralTimerModified { chat_id, timer } => {
+            EventType::ChatEphemeralTimerModified { chat_id, timer } => {
                 ChatEphemeralTimerModified {
                     chat_id: chat_id.to_u32(),
                     timer: timer.to_u32(),
                 }
             }
-            CoreEventType::ContactsChanged(contact) => ContactsChanged {
+            EventType::ContactsChanged(contact) => ContactsChanged {
                 contact_id: contact.map(|c| c.to_u32()),
             },
-            CoreEventType::LocationChanged(contact) => LocationChanged {
+            EventType::LocationChanged(contact) => LocationChanged {
                 contact_id: contact.map(|c| c.to_u32()),
             },
-            CoreEventType::ConfigureProgress { progress, comment } => {
+            EventType::ConfigureProgress { progress, comment } => {
                 ConfigureProgress { progress, comment }
             }
-            CoreEventType::ImexProgress(progress) => ImexProgress { progress },
-            CoreEventType::ImexFileWritten(path) => ImexFileWritten {
+            EventType::ImexProgress(progress) => ImexProgress { progress },
+            EventType::ImexFileWritten(path) => ImexFileWritten {
                 path: path.to_str().unwrap_or_default().to_owned(),
             },
-            CoreEventType::SecurejoinInviterProgress {
+            EventType::SecurejoinInviterProgress {
                 contact_id,
                 progress,
             } => SecurejoinInviterProgress {
                 contact_id: contact_id.to_u32(),
                 progress,
             },
-            CoreEventType::SecurejoinJoinerProgress {
+            EventType::SecurejoinJoinerProgress {
                 contact_id,
                 progress,
             } => SecurejoinJoinerProgress {
                 contact_id: contact_id.to_u32(),
                 progress,
             },
-            CoreEventType::ConnectivityChanged => ConnectivityChanged,
-            CoreEventType::SelfavatarChanged => SelfavatarChanged,
-            CoreEventType::WebxdcStatusUpdate {
+            EventType::ConnectivityChanged => ConnectivityChanged,
+            EventType::SelfavatarChanged => SelfavatarChanged,
+            EventType::WebxdcStatusUpdate {
                 msg_id,
                 status_update_serial,
             } => WebxdcStatusUpdate {
                 msg_id: msg_id.to_u32(),
                 status_update_serial: status_update_serial.to_u32(),
             },
-            CoreEventType::WebxdcInstanceDeleted { msg_id } => WebxdcInstanceDeleted {
+            EventType::WebxdcInstanceDeleted { msg_id } => WebxdcInstanceDeleted {
                 msg_id: msg_id.to_u32(),
             },
         }
     }
 }
+
+#[cfg(test)]
+#[test]
+fn generate_events_ts_types_definition() {
+    let events = {
+        let mut buf = Vec::new();
+        let options = typescript_type_def::DefinitionFileOptions {
+            root_namespace: None,
+            ..typescript_type_def::DefinitionFileOptions::default()
+        };
+        typescript_type_def::write_definition_file::<_, JSONRPCEventType>(&mut buf, options)
+            .unwrap();
+        String::from_utf8(buf).unwrap()
+    };
+    std::fs::write("typescript/generated/events.ts", events).unwrap();
+}

deltachat-jsonrpc/src/api/mod.rs

@@ -41,6 +41,7 @@ pub mod types;
 use num_traits::FromPrimitive;
 use types::account::Account;
 use types::chat::FullChat;
+use types::chat_list::ChatListEntry;
 use types::contact::ContactObject;
 use types::http::HttpResponse;
 use types::message::MessageData;
@@ -48,7 +49,6 @@ use types::message::MessageObject;
 use types::provider_info::ProviderInfo;
 use types::webxdc::WebxdcMessageInfo;
 
-use self::events::Event;
 use self::types::message::MessageLoadResult;
 use self::types::{
     chat::{BasicChat, JSONRPCChatVisibility, MuteDuration},
@@ -165,16 +165,6 @@ impl CommandApi {
         get_info()
     }
 
-    /// Get the next event.
-    async fn get_next_event(&self) -> Result<Event> {
-        let event_emitter = self.accounts.read().await.get_event_emitter();
-        event_emitter
-            .recv()
-            .await
-            .map(|event| event.into())
-            .context("event channel is closed")
-    }
-
     // ---------------------------------------------
     // Account Management
     // ---------------------------------------------
@@ -216,6 +206,8 @@ impl CommandApi {
             let context_option = self.accounts.read().await.get_account(id);
             if let Some(ctx) = context_option {
                 accounts.push(Account::from_context(&ctx, id).await?)
+            } else {
+                println!("account with id {id} doesn't exist anymore");
             }
         }
         Ok(accounts)
@@ -462,49 +454,6 @@ impl CommandApi {
         ChatId::new(chat_id).get_fresh_msg_cnt(&ctx).await
     }
 
-    /// Gets messages to be processed by the bot and returns their IDs.
-    ///
-    /// Only messages with database ID higher than `last_msg_id` config value
-    /// are returned. After processing the messages, the bot should
-    /// update `last_msg_id` by calling [`markseen_msgs`]
-    /// or manually updating the value to avoid getting already
-    /// processed messages.
-    ///
-    /// [`markseen_msgs`]: Self::markseen_msgs
-    async fn get_next_msgs(&self, account_id: u32) -> Result<Vec<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let msg_ids = ctx
-            .get_next_msgs()
-            .await?
-            .iter()
-            .map(|msg_id| msg_id.to_u32())
-            .collect();
-        Ok(msg_ids)
-    }
-
-    /// Waits for messages to be processed by the bot and returns their IDs.
-    ///
-    /// This function is similar to [`get_next_msgs`],
-    /// but waits for internal new message notification before returning.
-    /// New message notification is sent when new message is added to the database,
-    /// on initialization, when I/O is started and when I/O is stopped.
-    /// This allows bots to use `wait_next_msgs` in a loop to process
-    /// old messages after initialization and during the bot runtime.
-    /// To shutdown the bot, stopping I/O can be used to interrupt
-    /// pending or next `wait_next_msgs` call.
-    ///
-    /// [`get_next_msgs`]: Self::get_next_msgs
-    async fn wait_next_msgs(&self, account_id: u32) -> Result<Vec<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let msg_ids = ctx
-            .wait_next_msgs()
-            .await?
-            .iter()
-            .map(|msg_id| msg_id.to_u32())
-            .collect();
-        Ok(msg_ids)
-    }
-
     /// Estimate the number of messages that will be deleted
     /// by the set_config()-options `delete_device_after` or `delete_server_after`.
     /// This is typically used to show the estimated impact to the user
@@ -548,7 +497,7 @@ impl CommandApi {
         list_flags: Option<u32>,
         query_string: Option<String>,
         query_contact_id: Option<u32>,
-    ) -> Result<Vec<u32>> {
+    ) -> Result<Vec<ChatListEntry>> {
         let ctx = self.get_context(account_id).await?;
         let list = Chatlist::try_load(
             &ctx,
@@ -557,9 +506,12 @@ impl CommandApi {
             query_contact_id.map(ContactId::new),
         )
         .await?;
-        let mut l: Vec<u32> = Vec::with_capacity(list.len());
+        let mut l: Vec<ChatListEntry> = Vec::with_capacity(list.len());
         for i in 0..list.len() {
-            l.push(list.get_chat_id(i)?.to_u32());
+            l.push(ChatListEntry(
+                list.get_chat_id(i)?.to_u32(),
+                list.get_msg_id(i)?.unwrap_or_default().to_u32(),
+            ));
         }
         Ok(l)
     }
@@ -567,18 +519,19 @@ impl CommandApi {
     async fn get_chatlist_items_by_entries(
         &self,
         account_id: u32,
-        entries: Vec<u32>,
+        entries: Vec<ChatListEntry>,
     ) -> Result<HashMap<u32, ChatListItemFetchResult>> {
+        // todo custom json deserializer for ChatListEntry?
         let ctx = self.get_context(account_id).await?;
         let mut result: HashMap<u32, ChatListItemFetchResult> =
             HashMap::with_capacity(entries.len());
-        for &entry in entries.iter() {
+        for entry in entries.iter() {
             result.insert(
-                entry,
+                entry.0,
                 match get_chat_list_item_by_id(&ctx, entry).await {
                     Ok(res) => res,
                     Err(err) => ChatListItemFetchResult::Error {
-                        id: entry,
+                        id: entry.0,
                         error: format!("{err:#}"),
                     },
                 },
@@ -992,11 +945,6 @@ impl CommandApi {
     /// Moreover, timer is started for incoming ephemeral messages.
     /// This also happens for contact requests chats.
     ///
-    /// This function updates `last_msg_id` configuration value
-    /// to the maximum of the current value and IDs passed to this function.
-    /// Bots which mark messages as seen can rely on this side effect
-    /// to avoid updating `last_msg_id` value manually.
-    ///
     /// One #DC_EVENT_MSGS_NOTICED event is emitted per modified chat.
     async fn markseen_msgs(&self, account_id: u32, msg_ids: Vec<u32>) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
@@ -1135,17 +1083,17 @@ impl CommandApi {
     }
 
     /// Search messages containing the given query string.
-    /// Searching can be done globally (chat_id=None) or in a specified chat only (chat_id set).
+    /// Searching can be done globally (chat_id=0) or in a specified chat only (chat_id set).
     ///
-    /// Global search results are typically displayed using dc_msg_get_summary(), chat
-    /// search results may just highlight the corresponding messages and present a
+    /// Global chat results are typically displayed using dc_msg_get_summary(), chat
+    /// search results may just hilite the corresponding messages and present a
     /// prev/next button.
     ///
-    /// For the global search, the result is limited to 1000 messages,
-    /// this allows an incremental search done fast.
-    /// So, when getting exactly 1000 messages, the result actually may be truncated;
-    /// the UIs may display sth. like "1000+ messages found" in this case.
-    /// The chat search (if chat_id is set) is not limited.
+    /// For global search, result is limited to 1000 messages,
+    /// this allows incremental search done fast.
+    /// So, when getting exactly 1000 results, the result may be truncated;
+    /// the UIs may display sth. as "1000+ messages found" in this case.
+    /// Chat search (if a chat_id is set) is not limited.
     async fn search_messages(
         &self,
         account_id: u32,
@@ -1763,15 +1711,6 @@ impl CommandApi {
         Ok(msg_id)
     }
 
-    /// Checks if messages can be sent to a given chat.
-    async fn can_send(&self, account_id: u32, chat_id: u32) -> Result<bool> {
-        let ctx = self.get_context(account_id).await?;
-        let chat_id = ChatId::new(chat_id);
-        let chat = Chat::load_from_db(&ctx, chat_id).await?;
-        let can_send = chat.can_send(&ctx).await?;
-        Ok(can_send)
-    }
-
     // ---------------------------------------------
     //           functions for the composer
     //    the composer is the message input field

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

@@ -1,6 +1,6 @@
 use std::time::{Duration, SystemTime};
 
-use anyhow::{anyhow, bail, Context as _, Result};
+use anyhow::{anyhow, bail, Result};
 use deltachat::chat::{self, get_chat_contacts, ChatVisibility};
 use deltachat::chat::{Chat, ChatId};
 use deltachat::constants::Chattype;
@@ -53,9 +53,7 @@ impl FullChat {
             contacts.push(
                 ContactObject::try_from_dc_contact(
                     context,
-                    Contact::load_from_db(context, *contact_id)
-                        .await
-                        .context("failed to load contact")?,
+                    Contact::load_from_db(context, *contact_id).await?,
                 )
                 .await?,
             )
@@ -75,8 +73,7 @@ impl FullChat {
         let was_seen_recently = if chat.get_type() == Chattype::Single {
             match contact_ids.get(0) {
                 Some(contact) => Contact::load_from_db(context, *contact)
-                    .await
-                    .context("failed to load contact for was_seen_recently")?
+                    .await?
                     .was_seen_recently(),
                 None => false,
             }

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

@@ -1,18 +1,23 @@
-use anyhow::{Context, Result};
-use deltachat::chat::{Chat, ChatId};
-use deltachat::chatlist::get_last_message_for_chat;
+use anyhow::Result;
 use deltachat::constants::*;
 use deltachat::contact::{Contact, ContactId};
 use deltachat::{
     chat::{get_chat_contacts, ChatVisibility},
     chatlist::Chatlist,
 };
+use deltachat::{
+    chat::{Chat, ChatId},
+    message::MsgId,
+};
 use num_traits::cast::ToPrimitive;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
 
+#[derive(Deserialize, Serialize, TypeDef)]
+pub struct ChatListEntry(pub u32, pub u32);
+
 #[derive(Serialize, TypeDef)]
 #[serde(tag = "type")]
 pub enum ChatListItemFetchResult {
@@ -51,9 +56,14 @@ pub enum ChatListItemFetchResult {
 
 pub(crate) async fn get_chat_list_item_by_id(
     ctx: &deltachat::context::Context,
-    entry: u32,
+    entry: &ChatListEntry,
 ) -> Result<ChatListItemFetchResult> {
-    let chat_id = ChatId::new(entry);
+    let chat_id = ChatId::new(entry.0);
+    let last_msgid = match entry.1 {
+        0 => None,
+        _ => Some(MsgId::new(entry.1)),
+    };
+
     let fresh_message_counter = chat_id.get_fresh_msg_cnt(ctx).await?;
 
     if chat_id.is_archived_link() {
@@ -62,12 +72,8 @@ pub(crate) async fn get_chat_list_item_by_id(
         });
     }
 
-    let last_msgid = get_last_message_for_chat(ctx, chat_id).await?;
-
-    let chat = Chat::load_from_db(ctx, chat_id).await.context("chat")?;
-    let summary = Chatlist::get_summary2(ctx, chat_id, last_msgid, Some(&chat))
-        .await
-        .context("summary")?;
+    let chat = Chat::load_from_db(ctx, chat_id).await?;
+    let summary = Chatlist::get_summary2(ctx, chat_id, last_msgid, Some(&chat)).await?;
 
     let summary_text1 = summary.prefix.map_or_else(String::new, |s| s.to_string());
     let summary_text2 = summary.text.to_owned();
@@ -95,8 +101,7 @@ pub(crate) async fn get_chat_list_item_by_id(
         let contact = chat_contacts.get(0);
         let was_seen_recently = match contact {
             Some(contact) => Contact::load_from_db(ctx, *contact)
-                .await
-                .context("contact")?
+                .await?
                 .was_seen_recently(),
             None => false,
         };

deltachat-jsonrpc/src/webserver.rs

@@ -6,6 +6,7 @@ use yerpc::axum::handle_ws_rpc;
 use yerpc::{RpcClient, RpcSession};
 
 mod api;
+use api::events::event_to_json_rpc_notification;
 use api::{Accounts, CommandApi};
 
 const DEFAULT_PORT: u16 = 20808;
@@ -43,5 +44,12 @@ async fn main() -> Result<(), std::io::Error> {
 async fn handler(ws: WebSocketUpgrade, Extension(api): Extension<CommandApi>) -> Response {
     let (client, out_receiver) = RpcClient::new();
     let session = RpcSession::new(client.clone(), api.clone());
+    tokio::spawn(async move {
+        let events = api.accounts.read().await.get_event_emitter();
+        while let Some(event) = events.recv().await {
+            let event = event_to_json_rpc_notification(event);
+            client.send_notification("event", Some(event)).await.ok();
+        }
+    });
     handle_ws_rpc(ws, out_receiver, session).await
 }

deltachat-jsonrpc/typescript/example/example.ts

@@ -67,7 +67,7 @@ async function run() {
       null,
       null
     );
-    for (const chatId of chats) {
+    for (const [chatId, _messageId] of chats) {
       const chat = await client.rpc.getFullChatById(selectedAccount, chatId);
       write($main, `<h3>${chat.name}</h3>`);
       const messageIds = await client.rpc.getMessageIds(

deltachat-jsonrpc/typescript/package.json

@@ -55,5 +55,5 @@
   },
   "type": "module",
   "types": "dist/deltachat.d.ts",
-  "version": "1.114.0"
+  "version": "1.112.10"
 }

deltachat-jsonrpc/typescript/src/client.ts

@@ -1,6 +1,7 @@
 import * as T from "../generated/types.js";
 import * as RPC from "../generated/jsonrpc.js";
 import { RawClient } from "../generated/client.js";
+import { Event } from "../generated/events.js";
 import { WebsocketTransport, BaseTransport, Request } from "yerpc";
 import { TinyEmitter } from "@deltachat/tiny-emitter";
 
@@ -35,33 +36,27 @@ export class BaseDeltaChat<
   rpc: RawClient;
   account?: T.Account;
   private contextEmitters: { [key: number]: TinyEmitter<ContextEvents> } = {};
-
-  //@ts-ignore
-  private eventTask: Promise<void>;
-
-  constructor(public transport: Transport, startEventLoop: boolean) {
+  constructor(public transport: Transport) {
     super();
     this.rpc = new RawClient(this.transport);
-    if (startEventLoop) {
-      this.eventTask = this.eventLoop();
-    }
-  }
+    this.transport.on("request", (request: Request) => {
+      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);
 
-  async eventLoop(): Promise<void> {
-    while (true) {
-      const event = await this.rpc.getNextEvent();
-      this.emit(event.event.type, event.context_id, event.event as any);
-      this.emit("ALL", event.context_id, event.event as any);
-
-      if (this.contextEmitters[event.context_id]) {
-        this.contextEmitters[event.context_id].emit(
-          event.event.type,
-          //@ts-ignore
-          event.event as any
-        );
-        this.contextEmitters[event.context_id].emit("ALL", 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);
+        }
       }
-    }
+    });
   }
 
   async listAccounts(): Promise<T.Account[]> {
@@ -80,12 +75,10 @@ export class BaseDeltaChat<
 
 export type Opts = {
   url: string;
-  startEventLoop: boolean;
 };
 
 export const DEFAULT_OPTS: Opts = {
   url: "ws://localhost:20808/ws",
-  startEventLoop: true,
 };
 export class DeltaChat extends BaseDeltaChat<WebsocketTransport> {
   opts: Opts;
@@ -93,24 +86,20 @@ export class DeltaChat extends BaseDeltaChat<WebsocketTransport> {
     this.transport.close();
   }
   constructor(opts?: Opts | string) {
-    if (typeof opts === "string") {
-      opts = { ...DEFAULT_OPTS, url: opts };
-    } else if (opts) {
-      opts = { ...DEFAULT_OPTS, ...opts };
-    } else {
-      opts = { ...DEFAULT_OPTS };
-    }
+    if (typeof opts === "string") opts = { url: opts };
+    if (opts) opts = { ...DEFAULT_OPTS, ...opts };
+    else opts = { ...DEFAULT_OPTS };
     const transport = new WebsocketTransport(opts.url);
-    super(transport, opts.startEventLoop);
+    super(transport);
     this.opts = opts;
   }
 }
 
 export class StdioDeltaChat extends BaseDeltaChat<StdioTransport> {
   close() {}
-  constructor(input: any, output: any, startEventLoop: boolean) {
+  constructor(input: any, output: any) {
     const transport = new StdioTransport(input, output);
-    super(transport, startEventLoop);
+    super(transport);
   }
 }
 

deltachat-jsonrpc/typescript/src/lib.ts

@@ -1,5 +1,6 @@
 export * as RPC from "../generated/jsonrpc.js";
 export * as T from "../generated/types.js";
+export * from "../generated/events.js";
 export { RawClient } from "../generated/client.js";
 export * from "./client.js";
 export * as yerpc from "yerpc";

deltachat-jsonrpc/typescript/test/basic.ts

@@ -12,7 +12,7 @@ describe("basic tests", () => {
 
   before(async () => {
     serverHandle = await startServer();
-    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout, true);
+    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout);
     // dc.on("ALL", (event) => {
     //console.log("event", event);
     // });

deltachat-jsonrpc/typescript/test/online.ts

@@ -27,7 +27,7 @@ describe("online tests", function () {
       this.skip();
     }
     serverHandle = await startServer();
-    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout, true);
+    dc = new DeltaChat(serverHandle.stdin, serverHandle.stdout);
 
     dc.on("ALL", (contextId, { type }) => {
       if (type !== "Info") console.log(contextId, type);

deltachat-repl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.114.0"
+version = "1.112.10"
 license = "MPL-2.0"
 edition = "2021"
 
@@ -8,10 +8,10 @@ edition = "2021"
 ansi_term = "0.12.1"
 anyhow = "1"
 deltachat = { path = "..", features = ["internals"]}
-dirs = "5"
+dirs = "4"
 log = "0.4.16"
 pretty_env_logger = "0.4"
-rusqlite = "0.29"
+rusqlite = "0.28"
 rustyline = "11"
 tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 

deltachat-repl/src/cmdline.rs

@@ -563,7 +563,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             context.maybe_network().await;
         }
         "housekeeping" => {
-            sql::housekeeping(&context).await.log_err(&context).ok();
+            sql::housekeeping(&context).await.ok_or_log(&context);
         }
         "listchats" | "listarchived" | "chats" => {
             let listflags = if arg0 == "listarchived" {

deltachat-rpc-client/examples/echobot_no_hooks.py

@@ -6,7 +6,7 @@ import asyncio
 import logging
 import sys
 
-from deltachat_rpc_client import DeltaChat, EventType, Rpc, SpecialContactId
+from deltachat_rpc_client import DeltaChat, EventType, Rpc
 
 
 async def main():
@@ -30,9 +30,9 @@ async def main():
             await deltachat.start_io()
 
         async def process_messages():
-            for message in await account.get_next_messages():
+            for message in await account.get_fresh_messages_in_arrival_order():
                 snapshot = await message.get_snapshot()
-                if snapshot.from_id != SpecialContactId.SELF and not snapshot.is_bot and not snapshot.is_info:
+                if not snapshot.is_bot and not snapshot.is_info:
                     await snapshot.chat.send_text(snapshot.text)
                 await snapshot.message.mark_seen()
 

deltachat-rpc-client/src/deltachat_rpc_client/__init__.py

@@ -3,7 +3,7 @@ from ._utils import AttrDict, run_bot_cli, run_client_cli
 from .account import Account
 from .chat import Chat
 from .client import Bot, Client
-from .const import EventType, SpecialContactId
+from .const import EventType
 from .contact import Contact
 from .deltachat import DeltaChat
 from .message import Message
@@ -19,7 +19,6 @@ __all__ = [
     "DeltaChat",
     "EventType",
     "Message",
-    "SpecialContactId",
     "Rpc",
     "run_bot_cli",
     "run_client_cli",

deltachat-rpc-client/src/deltachat_rpc_client/account.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, List, Optional, Tuple, Union
-from warnings import warn
 
 from ._utils import AttrDict
 from .chat import Chat
@@ -177,7 +176,7 @@ class Account:
 
         entries = await self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
         if not snapshot:
-            return [Chat(self, entry) for entry in entries]
+            return [Chat(self, entry[0]) for entry in entries]
 
         items = await self._rpc.get_chatlist_items_by_entries(self.id, entries)
         chats = []
@@ -240,22 +239,7 @@ class Account:
         fresh_msg_ids = await self._rpc.get_fresh_msgs(self.id)
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
 
-    async def get_next_messages(self) -> List[Message]:
-        """Return a list of next messages."""
-        next_msg_ids = await self._rpc.get_next_msgs(self.id)
-        return [Message(self, msg_id) for msg_id in next_msg_ids]
-
-    async def wait_next_messages(self) -> List[Message]:
-        """Wait for new messages and return a list of them."""
-        next_msg_ids = await self._rpc.wait_next_msgs(self.id)
-        return [Message(self, msg_id) for msg_id in next_msg_ids]
-
     async def get_fresh_messages_in_arrival_order(self) -> List[Message]:
         """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
-        warn(
-            "get_fresh_messages_in_arrival_order is deprecated, use get_next_messages instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
         fresh_msg_ids = sorted(await self._rpc.get_fresh_msgs(self.id))
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]

deltachat-rpc-client/src/deltachat_rpc_client/chat.py

@@ -105,10 +105,6 @@ class Chat:
         info = await self._rpc.get_full_chat_by_id(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    async def can_send(self) -> bool:
-        """Return true if messages can be sent to the chat."""
-        return await self._rpc.can_send(self.account.id, self.id)
-
     async def send_message(
         self,
         text: Optional[str] = None,

deltachat-rpc-client/src/deltachat_rpc_client/client.py

@@ -20,7 +20,7 @@ from ._utils import (
     parse_system_image_changed,
     parse_system_title_changed,
 )
-from .const import COMMAND_PREFIX, EventType, SpecialContactId, SystemMessageType
+from .const import COMMAND_PREFIX, EventType, SystemMessageType
 from .events import (
     EventFilter,
     GroupImageChanged,
@@ -189,10 +189,9 @@ class Client:
 
     async def _process_messages(self) -> None:
         if self._should_process_messages:
-            for message in await self.account.get_next_messages():
+            for message in await self.account.get_fresh_messages_in_arrival_order():
                 snapshot = await message.get_snapshot()
-                if snapshot.from_id not in [SpecialContactId.SELF, SpecialContactId.DEVICE]:
-                    await self._on_new_msg(snapshot)
+                await self._on_new_msg(snapshot)
                 if snapshot.is_info and snapshot.system_message_type != SystemMessageType.WEBXDC_INFO_MESSAGE:
                     await self._handle_info_msg(snapshot)
                 await snapshot.message.mark_seen()

deltachat-rpc-client/src/deltachat_rpc_client/rpc.py

@@ -23,9 +23,7 @@ class Rpc:
         self.event_queues: Dict[int, asyncio.Queue]
         # Map from request ID to `asyncio.Future` returning the response.
         self.request_events: Dict[int, asyncio.Future]
-        self.closing: bool
         self.reader_task: asyncio.Task
-        self.events_task: asyncio.Task
 
     async def start(self) -> None:
         self.process = await asyncio.create_subprocess_exec(
@@ -37,15 +35,10 @@ class Rpc:
         self.id = 0
         self.event_queues = {}
         self.request_events = {}
-        self.closing = False
         self.reader_task = asyncio.create_task(self.reader_loop())
-        self.events_task = asyncio.create_task(self.events_loop())
 
     async def close(self) -> None:
         """Terminate RPC server process and wait until the reader loop finishes."""
-        self.closing = True
-        await self.stop_io_for_all_accounts()
-        await self.events_task
         self.process.terminate()
         await self.reader_task
 
@@ -65,28 +58,21 @@ class Rpc:
             if "id" in response:
                 fut = self.request_events.pop(response["id"])
                 fut.set_result(response)
+            elif response["method"] == "event":
+                # An event notification.
+                params = response["params"]
+                account_id = params["contextId"]
+                if account_id not in self.event_queues:
+                    self.event_queues[account_id] = asyncio.Queue()
+                await self.event_queues[account_id].put(params["event"])
             else:
                 print(response)
 
-    async def get_queue(self, account_id: int) -> asyncio.Queue:
-        if account_id not in self.event_queues:
-            self.event_queues[account_id] = asyncio.Queue()
-        return self.event_queues[account_id]
-
-    async def events_loop(self) -> None:
-        """Requests new events and distributes them between queues."""
-        while True:
-            if self.closing:
-                return
-            event = await self.get_next_event()
-            account_id = event["context_id"]
-            queue = await self.get_queue(account_id)
-            await queue.put(event["event"])
-
     async def wait_for_event(self, account_id: int) -> Optional[dict]:
         """Waits for the next event from the given account and returns it."""
-        queue = await self.get_queue(account_id)
-        return await queue.get()
+        if account_id in self.event_queues:
+            return await self.event_queues[account_id].get()
+        return None
 
     def __getattr__(self, attr: str):
         async def method(*args, **kwargs) -> Any:

deltachat-rpc-client/tests/test_something.py

@@ -98,8 +98,8 @@ async def test_account(acfactory) -> None:
     assert await alice.get_chatlist()
     assert await alice.get_chatlist(snapshot=True)
     assert await alice.get_qr_code()
-    assert await alice.get_fresh_messages()
-    assert await alice.get_next_messages()
+    await alice.get_fresh_messages()
+    await alice.get_fresh_messages_in_arrival_order()
 
     group = await alice.create_group("test group")
     await group.add_contact(alice_contact_bob)
@@ -147,9 +147,7 @@ async def test_chat(acfactory) -> None:
     assert alice_chat_bob != bob_chat_alice
     assert repr(alice_chat_bob)
     await alice_chat_bob.delete()
-    assert not await bob_chat_alice.can_send()
     await bob_chat_alice.accept()
-    assert await bob_chat_alice.can_send()
     await bob_chat_alice.block()
     bob_chat_alice = await snapshot.sender.create_chat()
     await bob_chat_alice.mute()
@@ -305,29 +303,3 @@ async def test_bot(acfactory) -> None:
     await acfactory.process_message(from_account=user, to_client=bot, text="hello")
     event = await acfactory.process_message(from_account=user, to_client=bot, text="/help")
     mock.hook.assert_called_once_with(event.msg_id)
-
-
-@pytest.mark.asyncio()
-async def test_wait_next_messages(acfactory) -> None:
-    alice = await acfactory.new_configured_account()
-
-    # Create a bot account so it does not receive device messages in the beginning.
-    bot = await acfactory.new_preconfigured_account()
-    await bot.set_config("bot", "1")
-    await bot.configure()
-
-    # There are no old messages and the call returns immediately.
-    assert not await bot.wait_next_messages()
-
-    # Bot starts waiting for messages.
-    next_messages_task = asyncio.create_task(bot.wait_next_messages())
-
-    bot_addr = await bot.get_config("addr")
-    alice_contact_bot = await alice.create_contact(bot_addr, "Bob")
-    alice_chat_bot = await alice_contact_bot.create_chat()
-    await alice_chat_bot.send_text("Hello!")
-
-    next_messages = await next_messages_task
-    assert len(next_messages) == 1
-    snapshot = await next_messages[0].get_snapshot()
-    assert snapshot.text == "Hello!"

deltachat-rpc-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.114.0"
+version = "1.112.10"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -17,10 +17,9 @@ anyhow = "1"
 env_logger = { version = "0.10.0" }
 futures-lite = "1.12.0"
 log = "0.4"
-serde_json = "1.0.95"
+serde_json = "1.0.91"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.27.0", features = ["io-std"] }
-tokio-util = "0.7.7"
+tokio = { version = "1.25.0", features = ["io-std"] }
 yerpc = { version = "0.4.0", features = ["anyhow_expose"] }
 
 [features]

deltachat-rpc-server/src/main.rs

@@ -3,33 +3,18 @@ use std::env;
 ///!
 ///! It speaks JSON Lines over stdio.
 use std::path::PathBuf;
-use std::sync::Arc;
 
 use anyhow::{anyhow, Context as _, Result};
 use deltachat::constants::DC_VERSION_STR;
+use deltachat_jsonrpc::api::events::event_to_json_rpc_notification;
 use deltachat_jsonrpc::api::{Accounts, CommandApi};
 use futures_lite::stream::StreamExt;
 use tokio::io::{self, AsyncBufReadExt, BufReader};
-
-#[cfg(target_family = "unix")]
-use tokio::signal::unix as signal_unix;
-
-use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
-use tokio_util::sync::CancellationToken;
 use yerpc::{RpcClient, RpcSession};
 
 #[tokio::main(flavor = "multi_thread")]
-async fn main() {
-    let r = main_impl().await;
-    // From tokio documentation:
-    // "For technical reasons, stdin is implemented by using an ordinary blocking read on a separate
-    // thread, and it is impossible to cancel that read. This can make shutdown of the runtime hang
-    // until the user presses enter."
-    std::process::exit(if r.is_ok() { 0 } else { 1 });
-}
-
-async fn main_impl() -> Result<()> {
+async fn main() -> Result<()> {
     let mut args = env::args_os();
     let _program_name = args.next().context("no command line arguments found")?;
     if let Some(first_arg) = args.next() {
@@ -47,97 +32,59 @@ async fn main_impl() -> Result<()> {
         return Err(anyhow!("Unrecognized argument {:?}", arg));
     }
 
-    // Install signal handlers early so that the shutdown is graceful starting from here.
-    let _ctrl_c = tokio::signal::ctrl_c();
-    #[cfg(target_family = "unix")]
-    let mut sigterm = signal_unix::signal(signal_unix::SignalKind::terminate())?;
-
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
 
     let path = std::env::var("DC_ACCOUNTS_PATH").unwrap_or_else(|_| "accounts".to_string());
     log::info!("Starting with accounts directory `{}`.", path);
     let accounts = Accounts::new(PathBuf::from(&path)).await?;
+    let events = accounts.get_event_emitter();
 
     log::info!("Creating JSON-RPC API.");
-    let accounts = Arc::new(RwLock::new(accounts));
-    let state = CommandApi::from_arc(accounts.clone());
+    let state = CommandApi::new(accounts);
 
     let (client, mut out_receiver) = RpcClient::new();
-    let session = RpcSession::new(client.clone(), state.clone());
-    let main_cancel = CancellationToken::new();
+    let session = RpcSession::new(client.clone(), state);
+
+    // Events task converts core events to JSON-RPC notifications.
+    let events_task: JoinHandle<Result<()>> = tokio::spawn(async move {
+        while let Some(event) = events.recv().await {
+            let event = event_to_json_rpc_notification(event);
+            client.send_notification("event", Some(event)).await?;
+        }
+        Ok(())
+    });
 
     // Send task prints JSON responses to stdout.
-    let cancel = main_cancel.clone();
     let send_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        let _cancel_guard = cancel.clone().drop_guard();
-        loop {
-            let message = tokio::select! {
-                _ = cancel.cancelled() => break,
-                message = out_receiver.next() => match message {
-                    None => break,
-                    Some(message) => serde_json::to_string(&message)?,
-                }
-            };
+        while let Some(message) = out_receiver.next().await {
+            let message = serde_json::to_string(&message)?;
             log::trace!("RPC send {}", message);
             println!("{message}");
         }
         Ok(())
     });
 
-    let cancel = main_cancel.clone();
-    let sigterm_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        #[cfg(target_family = "unix")]
-        {
-            let _cancel_guard = cancel.clone().drop_guard();
-            tokio::select! {
-                _ = cancel.cancelled() => (),
-                _ = sigterm.recv() => {
-                    log::info!("got SIGTERM");
-                }
-            }
-        }
-        let _ = cancel;
-        Ok(())
-    });
-
     // Receiver task reads JSON requests from stdin.
-    let cancel = main_cancel.clone();
     let recv_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        let _cancel_guard = cancel.clone().drop_guard();
         let stdin = io::stdin();
         let mut lines = BufReader::new(stdin).lines();
-
-        loop {
-            let message = tokio::select! {
-                _ = cancel.cancelled() => break,
-                _ = tokio::signal::ctrl_c() => {
-                    log::info!("got ctrl-c event");
-                    break;
-                }
-                message = lines.next_line() => match message? {
-                    None => {
-                        log::info!("EOF reached on stdin");
-                        break;
-                    }
-                    Some(message) => message,
-                }
-            };
+        while let Some(message) = lines.next_line().await? {
             log::trace!("RPC recv {}", message);
             let session = session.clone();
             tokio::spawn(async move {
                 session.handle_incoming(&message).await;
             });
         }
+        log::info!("EOF reached on stdin");
         Ok(())
     });
 
-    main_cancel.cancelled().await;
-    accounts.read().await.stop_io().await;
-    drop(accounts);
-    drop(state);
-    send_task.await??;
-    sigterm_task.await??;
+    // Wait for the end of stdin.
     recv_task.await??;
 
+    // Shutdown the server.
+    send_task.abort();
+    events_task.abort();
+
     Ok(())
 }

deltachat_derive/Cargo.toml

@@ -8,5 +8,5 @@ license = "MPL-2.0"
 proc-macro = true
 
 [dependencies]
-syn = "2"
+syn = "1"
 quote = "1"

deny.toml

@@ -13,46 +13,34 @@ ignore = [
 # when upgrading.
 # Please keep this list alphabetically sorted.
 skip = [
-     { name = "base16ct", version = "0.1.1" },
      { name = "base64", version = "<0.21" },
-     { name = "bitflags", version = "1.3.2" },
      { name = "block-buffer", version = "<0.10" },
-     { name = "clap_lex", version = "0.2.4" },
      { name = "clap", version = "3.2.23" },
+     { name = "clap_lex", version = "0.2.4" },
      { name = "convert_case", version = "0.4.0" },
-     { name = "curve25519-dalek", version = "3.2.0" },
+     { name = "darling", version = "<0.14" },
      { name = "darling_core", version = "<0.14" },
      { name = "darling_macro", version = "<0.14" },
-     { name = "darling", version = "<0.14" },
-     { name = "der", version = "0.6.1" },
      { name = "digest", version = "<0.10" },
-     { name = "ed25519-dalek", version = "1.0.1" },
-     { name = "ed25519", version = "1.5.3" },
      { name = "env_logger", version = "<0.10" },
      { name = "getrandom", version = "<0.2" },
      { name = "hermit-abi", version = "<0.3" },
      { name = "humantime", version = "<2.1" },
      { name = "idna", version = "<0.3" },
-     { name = "libm", version = "0.1.4" },
-     { name = "pem-rfc7468", version = "0.6.0" },
-     { name = "pkcs8", version = "0.9.0" },
+     { name = "nom", version = "<7.1" },
      { name = "quick-error", version = "<2.0" },
+     { name = "rand", version = "<0.8" },
      { name = "rand_chacha", version = "<0.3" },
      { name = "rand_core", version = "<0.6" },
-     { name = "rand", version = "<0.8" },
-     { name = "redox_syscall", version = "0.2.16" },
-     { name = "sec1", version = "0.3.0" },
      { name = "sha2", version = "<0.10" },
-     { name = "signature", version = "1.6.4" },
      { name = "spin", version = "<0.9.6" },
-     { name = "spki", version = "0.6.0" },
-     { name = "syn", version = "1.0.109" },
      { name = "time", version = "<0.3" },
+     { name = "version_check", version = "<0.9" },
      { name = "wasi", version = "<0.11" },
+     { name = "windows-sys", version = "<0.45" },
      { name = "windows_aarch64_msvc", version = "<0.42" },
      { name = "windows_i686_gnu", version = "<0.42" },
      { name = "windows_i686_msvc", version = "<0.42" },
-     { name = "windows-sys", version = "<0.45" },
      { name = "windows_x86_64_gnu", version = "<0.42" },
      { name = "windows_x86_64_msvc", version = "<0.42" },
 ]

node/constants.js

@@ -151,7 +151,6 @@ module.exports = {
   DC_STR_AEAP_EXPLANATION_AND_LINK: 123,
   DC_STR_ARCHIVEDCHATS: 40,
   DC_STR_AUDIO: 11,
-  DC_STR_BACKUP_TRANSFER_MSG_BODY: 163,
   DC_STR_BACKUP_TRANSFER_QR: 162,
   DC_STR_BAD_TIME_MSG_BODY: 85,
   DC_STR_BROADCAST_LIST: 115,

node/lib/constants.ts

@@ -151,7 +151,6 @@ export enum C {
   DC_STR_AEAP_EXPLANATION_AND_LINK = 123,
   DC_STR_ARCHIVEDCHATS = 40,
   DC_STR_AUDIO = 11,
-  DC_STR_BACKUP_TRANSFER_MSG_BODY = 163,
   DC_STR_BACKUP_TRANSFER_QR = 162,
   DC_STR_BAD_TIME_MSG_BODY = 85,
   DC_STR_BROADCAST_LIST = 115,

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.114.0"
+  "version": "1.112.10"
 }

python/README.rst

@@ -12,17 +12,17 @@ a low-level Chat/Contact/Message API to user interfaces and bots.
 Installing pre-built packages (Linux-only)
 ==========================================
 
-If you have a Linux system you may install the ``deltachat`` binary "wheel" packages
+If you have a Linux system you may try to install the ``deltachat`` binary "wheel" packages
 without any "build-from-source" steps.
 Otherwise you need to `compile the Delta Chat bindings yourself`__.
 
 __ sourceinstall_
 
-We recommend to first create a fresh Python virtual environment
-and activate it in your shell::
+We recommend to first `install virtualenv <https://virtualenv.pypa.io/en/stable/installation.html>`_,
+then create a fresh Python virtual environment and activate it in your shell::
 
-    python -m venv env
-    source env/bin/activate
+        virtualenv env  # or: python -m venv
+        source env/bin/activate
 
 Afterwards, invoking ``python`` or ``pip install`` only
 modifies files in your ``env`` directory and leaves
@@ -40,14 +40,16 @@ To verify it worked::
 Running tests
 =============
 
-Recommended way to run tests is using `scripts/run-python-test.sh`
-script provided in the core repository.
+Recommended way to run tests is using `tox <https://tox.wiki>`_.
+After successful binding installation you can install tox
+and run the tests::
 
-This script compiles the library in debug mode and runs the tests using `tox`_.
-By default it will run all "offline" tests and skip all functional
+    pip install tox
+    tox -e py3
+
+This will run all "offline" tests and skip all functional
 end-to-end tests that require accounts on real e-mail servers.
 
-.. _`tox`: https://tox.wiki
 .. _livetests:
 
 Running "live" tests with temporary accounts
@@ -59,32 +61,13 @@ Please feel free to contact us through a github issue or by e-mail and we'll sen
 
     export DCC_NEW_TMP_EMAIL=<URL you got from us>
 
-With this account-creation setting, pytest runs create ephemeral e-mail accounts on the http://testrun.org server.
-These accounts are removed automatically as they expire.
-After setting the variable, either rerun `scripts/run-python-test.sh`
-or run offline and online tests with `tox` directly::
+With this account-creation setting, pytest runs create ephemeral e-mail accounts on the http://testrun.org server.  These accounts exists only for one hour and then are removed completely.
+One hour is enough to invoke pytest and run all offline and online tests::
 
-    tox -e py
+    tox -e py3
 
 Each test run creates new accounts.
 
-Developing the bindings
------------------------
-
-If you want to develop or debug the bindings,
-you can create a testing development environment using `tox`::
-
-    tox -c python --devenv env
-    . env/bin/activate
-
-Inside this environment the bindings are installed
-in editable mode (as if installed with `python -m pip install -e`)
-together with the testing dependencies like `pytest` and its plugins.
-
-You can then edit the source code in the development tree
-and quickly run `pytest` manually without waiting  for `tox`
-to recreating the virtual environment each time.
-
 .. _sourceinstall:
 
 Installing bindings from source
@@ -106,34 +89,20 @@ To install the Delta Chat Python bindings make sure you have Python3 installed.
 E.g. on Debian-based systems `apt install python3 python3-pip
 python3-venv` should give you a usable python installation.
 
-First, build the core library::
+Ensure you are in the deltachat-core-rust/python directory, create the
+virtual environment with dependencies using tox
+and activate it in your shell::
 
-   cargo build --release -p deltachat_ffi --features jsonrpc
-
-`jsonrpc` feature is required even if not used by the bindings
-because `deltachat.h` includes JSON-RPC functions unconditionally.
-
-Create the virtual environment and activate it:
-
-   python -m venv env
+   cd python
+   tox --devenv env
    source env/bin/activate
 
-Build and install the bindings:
+You should now be able to build the python bindings using the supplied script::
 
-   export DCC_RS_DEV="$PWD"
-   export DCC_RS_TARGET=release
-   python -m pip install ./python
+   python3 install_python_bindings.py
 
-`DCC_RS_DEV` environment variable specifies the location of
-the core development tree. If this variable is not set,
-`libdeltachat` library and `deltachat.h` header are expected
-to be installed system-wide.
-
-When `DCC_RS_DEV` is set, `DCC_RS_TARGET` specifies
-the build profile name to look up the artifacts
-in the target directory.
-In this case setting it can be skipped because
-`DCC_RS_TARGET=release` is the default.
+The core compilation and bindings building might take a while,
+depending on the speed of your machine.
 
 Building manylinux based wheels
 ===============================

python/examples/test_examples.py

@@ -24,8 +24,6 @@ def test_echo_quit_plugin(acfactory, lp):
     lp.sec("creating a temp account to contact the bot")
     (ac1,) = acfactory.get_online_accounts(1)
 
-    botproc.await_resync()
-
     lp.sec("sending a message to the bot")
     bot_contact = ac1.create_contact(botproc.addr)
     bot_chat = bot_contact.create_chat()
@@ -42,7 +40,7 @@ def test_echo_quit_plugin(acfactory, lp):
 
 def test_group_tracking_plugin(acfactory, lp):
     lp.sec("creating one group-tracking bot and two temp accounts")
-    botproc = acfactory.run_bot_process(group_tracking)
+    botproc = acfactory.run_bot_process(group_tracking, ffi=False)
 
     ac1, ac2 = acfactory.get_online_accounts(2)
 
@@ -54,8 +52,6 @@ def test_group_tracking_plugin(acfactory, lp):
     ac1.add_account_plugin(FFIEventLogger(ac1))
     ac2.add_account_plugin(FFIEventLogger(ac2))
 
-    botproc.await_resync()
-
     lp.sec("creating bot test group with bot")
     bot_contact = ac1.create_contact(botproc.addr)
     ch = ac1.create_group_chat("bot test group")

python/install_python_bindings.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+"""
+ setup a python binding development in-place install with cargo debug symbols.
+"""
+
+import os
+import subprocess
+import sys
+
+if __name__ == "__main__":
+    target = os.environ.get("DCC_RS_TARGET")
+    if target is None:
+        os.environ["DCC_RS_TARGET"] = target = "debug"
+    if "DCC_RS_DEV" not in os.environ:
+        dn = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        os.environ["DCC_RS_DEV"] = dn
+
+    cmd = ["cargo", "build", "-p", "deltachat_ffi", "--features", "jsonrpc"]
+
+    if target == "release":
+        os.environ["CARGO_PROFILE_RELEASE_LTO"] = "on"
+        cmd.append("--release")
+
+    print("running:", " ".join(cmd))
+    subprocess.check_call(cmd)
+    subprocess.check_call("rm -rf build/ src/deltachat/*.so src/deltachat/*.dylib src/deltachat/*.dll", shell=True)
+
+    if len(sys.argv) <= 1 or sys.argv[1] != "onlybuild":
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-e", "."])

python/src/deltachat/account.py

@@ -376,22 +376,6 @@ class Account:
         dc_array = ffi.gc(lib.dc_get_fresh_msgs(self._dc_context), lib.dc_array_unref)
         return (x for x in iter_array(dc_array, lambda x: Message.from_db(self, x)) if x is not None)
 
-    def _wait_next_message_ids(self) -> List[int]:
-        """Return IDs of all next messages from all chats."""
-        dc_array = ffi.gc(lib.dc_wait_next_msgs(self._dc_context), lib.dc_array_unref)
-        return [lib.dc_array_get_id(dc_array, i) for i in range(lib.dc_array_get_cnt(dc_array))]
-
-    def wait_next_incoming_message(self) -> Message:
-        """Waits until the next incoming message
-        with ID higher than given is received and returns it."""
-        while True:
-            message_ids = self._wait_next_message_ids()
-            for msg_id in message_ids:
-                message = Message.from_db(self, msg_id)
-                if message and not message.is_from_self() and not message.is_from_device():
-                    self.set_config("last_msg_id", str(msg_id))
-                    return message
-
     def create_chat(self, obj) -> Chat:
         """Create a 1:1 chat with Account, Contact or e-mail address."""
         return self.create_contact(obj).create_chat()

python/src/deltachat/message.py

@@ -344,16 +344,6 @@ class Message:
         contact_id = lib.dc_msg_get_from_id(self._dc_msg)
         return Contact(self.account, contact_id)
 
-    def is_from_self(self):
-        """Return true if the message is sent by self."""
-        contact_id = lib.dc_msg_get_from_id(self._dc_msg)
-        return contact_id == const.DC_CONTACT_ID_SELF
-
-    def is_from_device(self):
-        """Return true if the message is sent by the device."""
-        contact_id = lib.dc_msg_get_from_id(self._dc_msg)
-        return contact_id == const.DC_CONTACT_ID_DEVICE
-
     #
     # Message State query methods
     #

python/src/deltachat/testplugin.py

@@ -676,13 +676,6 @@ class BotProcess:
                     print("+++IGN:", line)
                     ignored.append(line)
 
-    def await_resync(self):
-        self.fnmatch_lines(
-            """
-            *Resync: collected * message IDs in folder INBOX*
-        """,
-        )
-
 
 @pytest.fixture()
 def tmp_db_path(tmpdir):

python/tests/test_1_online.py

@@ -44,21 +44,21 @@ def test_configure_generate_key(acfactory, lp):
     lp.sec("ac1: send unencrypted message to ac2")
     chat.send_text("message1")
     lp.sec("ac2: waiting for message from ac1")
-    msg_in = ac2.wait_next_incoming_message()
+    msg_in = ac2._evtracker.wait_next_incoming_message()
     assert msg_in.text == "message1"
     assert not msg_in.is_encrypted()
 
     lp.sec("ac2: send encrypted message to ac1")
     msg_in.chat.send_text("message2")
     lp.sec("ac1: waiting for message from ac2")
-    msg2_in = ac1.wait_next_incoming_message()
+    msg2_in = ac1._evtracker.wait_next_incoming_message()
     assert msg2_in.text == "message2"
     assert msg2_in.is_encrypted()
 
     lp.sec("ac1: send encrypted message to ac2")
     msg2_in.chat.send_text("message3")
     lp.sec("ac2: waiting for message from ac1")
-    msg3_in = ac2.wait_next_incoming_message()
+    msg3_in = ac2._evtracker.wait_next_incoming_message()
     assert msg3_in.text == "message3"
     assert msg3_in.is_encrypted()
 
@@ -567,8 +567,7 @@ def test_moved_markseen(acfactory):
 
     with ac2.direct_imap.idle() as idle2:
         ac2.start_io()
-        ev = ac2._evtracker.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
-        msg = ac2.get_message_by_id(ev.data2)
+        msg = ac2._evtracker.wait_next_incoming_message()
 
         # Accept the contact request.
         msg.chat.accept()

python/tox.ini

@@ -43,7 +43,7 @@ deps =
     pygments
     restructuredtext_lint 
 commands =
-    black --quiet --check --diff setup.py src/deltachat examples/ tests/
+    black --quiet --check --diff setup.py install_python_bindings.py src/deltachat examples/ tests/
     ruff src/deltachat tests/ examples/
     rst-lint --encoding 'utf-8' README.rst
 

release-date.in

@@ -1 +1 @@
-2023-04-24
+2023-06-01

scripts/create-provider-data-rs.py

@@ -233,7 +233,7 @@ if __name__ == "__main__":
     else:
         now = datetime.datetime.fromisoformat(sys.argv[2])
     out_all += (
-        "pub static _PROVIDER_UPDATED: Lazy<chrono::NaiveDate> = "
+        "pub static PROVIDER_UPDATED: Lazy<chrono::NaiveDate> = "
         "Lazy::new(|| chrono::NaiveDate::from_ymd_opt("
         + str(now.year)
         + ", "

scripts/run-python-test.sh

@@ -12,7 +12,7 @@ export DCC_RS_DEV=`pwd`
 
 cd python
 
-cargo build -p deltachat_ffi --features jsonrpc
+python install_python_bindings.py onlybuild
 
 # remove and inhibit writing PYC files 
 rm -rf tests/__pycache__
@@ -22,5 +22,4 @@ export PYTHONDONTWRITEBYTECODE=1
 # run python tests (tox invokes pytest to run tests in python/tests)
 #TOX_PARALLEL_NO_SPINNER=1 tox -e lint,doc
 tox -e lint
-tox -e doc
-tox -e py -- "$@"
+tox -e doc,py3

scripts/zig-cc

@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-import subprocess
-import sys
-import os
-
-
-def flag_filter(flag: str) -> bool:
-    if flag == "-lc":
-        return False
-    if flag == "-Wl,-melf_i386":
-        return False
-    if "self-contained" in flag and "crt" in flag:
-        return False
-    return True
-
-
-def main():
-    args = [flag for flag in sys.argv[1:] if flag_filter(flag)]
-    zig_target = os.environ["ZIG_TARGET"]
-    zig_cpu = os.environ.get("ZIG_CPU")
-    if zig_cpu:
-        zig_cpu_args = ["-mcpu=" + zig_cpu]
-        args = [x for x in args if not x.startswith("-march")]
-    else:
-        zig_cpu_args = []
-
-    subprocess.run(
-        ["zig", "cc", "-target", zig_target, *zig_cpu_args, *args], check=True
-    )
-
-
-main()

scripts/zig-rpc-server.sh

@@ -1,15 +1,12 @@
 #!/bin/sh
 #
-# Build statically linked deltachat-rpc-server using zig.
+# Build statically linked deltachat-rpc-server using cargo-zigbuild.
 
 set -x
 set -e
 
 unset RUSTFLAGS
 
-# Pin Rust version to avoid uncontrolled changes in the compiler and linker flags.
-export RUSTUP_TOOLCHAIN=1.68.1
-
 ZIG_VERSION=0.11.0-dev.2213+515e1c93e
 
 # Download Zig
@@ -18,35 +15,9 @@ wget "https://ziglang.org/builds/zig-linux-x86_64-$ZIG_VERSION.tar.xz"
 tar xf "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
 export PATH="$PWD/zig-linux-x86_64-$ZIG_VERSION:$PATH"
 
-rustup target add i686-unknown-linux-musl
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_I686_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="x86-linux-musl" \
-cargo build --release --target i686-unknown-linux-musl -p deltachat-rpc-server --features vendored
+cargo install cargo-zigbuild
 
-rustup target add armv7-unknown-linux-musleabihf
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_ARMV7_UNKNOWN_LINUX_MUSLEABIHF_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="arm-linux-musleabihf" \
-ZIG_CPU="generic+v7a+vfp3-d32+thumb2-neon" \
-cargo build --release --target armv7-unknown-linux-musleabihf -p deltachat-rpc-server --features vendored
-
-rustup target add x86_64-unknown-linux-musl
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="x86_64-linux-musl" \
-cargo build --release --target x86_64-unknown-linux-musl -p deltachat-rpc-server --features vendored
-
-rustup target add aarch64-unknown-linux-musl
-CC="$PWD/scripts/zig-cc" \
-TARGET_CC="$PWD/scripts/zig-cc" \
-CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER="$PWD/scripts/zig-cc" \
-LD="$PWD/scripts/zig-cc" \
-ZIG_TARGET="aarch64-linux-musl" \
-cargo build --release --target aarch64-unknown-linux-musl -p deltachat-rpc-server --features vendored
+for TARGET in x86_64-unknown-linux-musl aarch64-unknown-linux-musl armv7-unknown-linux-musleabihf; do
+	rustup target add "$TARGET"
+	cargo zigbuild --release --target "$TARGET" -p deltachat-rpc-server --features vendored
+done

src/accounts.rs

@@ -6,7 +6,6 @@ use std::path::{Path, PathBuf};
 use anyhow::{ensure, Context as _, Result};
 use serde::{Deserialize, Serialize};
 use tokio::fs;
-use tokio::io::AsyncWriteExt;
 use uuid::Uuid;
 
 use crate::context::Context;
@@ -18,7 +17,6 @@ use crate::stock_str::StockStrings;
 pub struct Accounts {
     dir: PathBuf,
     config: Config,
-    /// Map from account ID to the account.
     accounts: BTreeMap<u32, Context>,
 
     /// Event channel to emit account manager errors.
@@ -79,12 +77,12 @@ impl Accounts {
         })
     }
 
-    /// Returns an account by its `id`:
+    /// Get an account by its `id`:
     pub fn get_account(&self, id: u32) -> Option<Context> {
         self.accounts.get(&id).cloned()
     }
 
-    /// Returns the currently selected account.
+    /// Get the currently selected account.
     pub fn get_selected_account(&self) -> Option<Context> {
         let id = self.config.get_selected_account();
         self.accounts.get(&id).cloned()
@@ -98,14 +96,14 @@ impl Accounts {
         }
     }
 
-    /// Selects the given account.
+    /// Select the given account.
     pub async fn select_account(&mut self, id: u32) -> Result<()> {
         self.config.select_account(id).await?;
 
         Ok(())
     }
 
-    /// Adds a new account and opens it.
+    /// Add a new account and opens it.
     ///
     /// Returns account ID.
     pub async fn add_account(&mut self) -> Result<u32> {
@@ -140,7 +138,7 @@ impl Accounts {
         Ok(account_config.id)
     }
 
-    /// Removes an account.
+    /// Remove an account.
     pub async fn remove_account(&mut self, id: u32) -> Result<()> {
         let ctx = self
             .accounts
@@ -161,7 +159,7 @@ impl Accounts {
         Ok(())
     }
 
-    /// Migrates an existing account into this structure.
+    /// Migrate an existing account into this structure.
     ///
     /// Returns the ID of new account.
     pub async fn migrate_account(&mut self, dbfile: PathBuf) -> Result<u32> {
@@ -303,7 +301,7 @@ pub const DB_NAME: &str = "dc.db";
 
 /// Account manager configuration file.
 #[derive(Debug, Clone, PartialEq)]
-struct Config {
+pub struct Config {
     file: PathBuf,
     inner: InnerConfig,
 }
@@ -327,8 +325,10 @@ impl Config {
             selected_account: 0,
             next_id: 1,
         };
-        let file = dir.join(CONFIG_NAME);
-        let mut cfg = Self { file, inner };
+        let cfg = Config {
+            file: dir.join(CONFIG_NAME),
+            inner,
+        };
 
         cfg.sync().await?;
 
@@ -336,24 +336,10 @@ impl Config {
     }
 
     /// Sync the inmemory representation to disk.
-    /// Takes a mutable reference because the saved file is a part of the `Config` state. This
-    /// protects from parallel calls resulting to a wrong file contents.
-    async fn sync(&mut self) -> Result<()> {
-        let tmp_path = self.file.with_extension("toml.tmp");
-        let mut file = fs::File::create(&tmp_path)
+    async fn sync(&self) -> Result<()> {
+        fs::write(&self.file, toml::to_string_pretty(&self.inner)?)
             .await
-            .context("failed to create a tmp config")?;
-        file.write_all(toml::to_string_pretty(&self.inner)?.as_bytes())
-            .await
-            .context("failed to write a tmp config")?;
-        file.sync_data()
-            .await
-            .context("failed to sync a tmp config")?;
-        drop(file);
-        fs::rename(&tmp_path, &self.file)
-            .await
-            .context("failed to rename config")?;
-        Ok(())
+            .context("failed to write config")
     }
 
     /// Read a configuration from the given file into memory.
@@ -373,7 +359,7 @@ impl Config {
             }
         }
 
-        let mut config = Self { file, inner };
+        let config = Self { file, inner };
         if modified {
             config.sync().await?;
         }
@@ -517,19 +503,17 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         let p: PathBuf = dir.path().join("accounts1");
 
-        {
-            let mut accounts = Accounts::new(p.clone()).await.unwrap();
-            accounts.add_account().await.unwrap();
+        let mut accounts1 = Accounts::new(p.clone()).await.unwrap();
+        accounts1.add_account().await.unwrap();
 
-            assert_eq!(accounts.accounts.len(), 1);
-            assert_eq!(accounts.config.get_selected_account(), 1);
-        }
-        {
-            let accounts = Accounts::open(p).await.unwrap();
+        let accounts2 = Accounts::open(p).await.unwrap();
 
-            assert_eq!(accounts.accounts.len(), 1);
-            assert_eq!(accounts.config.get_selected_account(), 1);
-        }
+        assert_eq!(accounts1.accounts.len(), 1);
+        assert_eq!(accounts1.config.get_selected_account(), 1);
+
+        assert_eq!(accounts1.dir, accounts2.dir);
+        assert_eq!(accounts1.config, accounts2.config,);
+        assert_eq!(accounts1.accounts.len(), accounts2.accounts.len());
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

src/authres.rs

@@ -308,7 +308,7 @@ async fn dkim_works_timestamp(context: &Context, from_domain: &str) -> Result<i6
         .sql
         .query_get_value(
             "SELECT dkim_works FROM sending_domains WHERE domain=?",
-            (from_domain,),
+            paramsv![from_domain],
         )
         .await?
         .unwrap_or(0);
@@ -325,7 +325,7 @@ async fn set_dkim_works_timestamp(
         .execute(
             "INSERT INTO sending_domains (domain, dkim_works) VALUES (?,?)
                 ON CONFLICT(domain) DO UPDATE SET dkim_works=excluded.dkim_works",
-            (from_domain, timestamp),
+            paramsv![from_domain, timestamp],
         )
         .await?;
     Ok(())

src/blob.rs

@@ -9,17 +9,21 @@ use std::path::{Path, PathBuf};
 
 use anyhow::{format_err, Context as _, Result};
 use futures::StreamExt;
-use image::{DynamicImage, ImageFormat, ImageOutputFormat};
+use image::{DynamicImage, ImageFormat};
 use num_traits::FromPrimitive;
 use tokio::io::AsyncWriteExt;
 use tokio::{fs, io};
 use tokio_stream::wrappers::ReadDirStream;
 
 use crate::config::Config;
-use crate::constants::{self, MediaQuality};
+use crate::constants::{
+    MediaQuality, BALANCED_AVATAR_SIZE, BALANCED_IMAGE_SIZE, WORSE_AVATAR_SIZE, WORSE_IMAGE_SIZE,
+};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::log::LogExt;
+use crate::message;
+use crate::message::Viewtype;
 
 /// Represents a file in the blob directory.
 ///
@@ -88,7 +92,7 @@ impl<'a> BlobObject<'a> {
                     if attempt >= MAX_ATTEMPT {
                         return Err(err).context("failed to create file");
                     } else if attempt == 1 && !dir.exists() {
-                        fs::create_dir_all(dir).await.log_err(context).ok();
+                        fs::create_dir_all(dir).await.ok_or_log(context);
                     } else {
                         name = format!("{}-{}{}", stem, rand::random::<u32>(), ext);
                     }
@@ -319,149 +323,119 @@ impl<'a> BlobObject<'a> {
             match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
                 .unwrap_or_default()
             {
-                MediaQuality::Balanced => constants::BALANCED_AVATAR_SIZE,
-                MediaQuality::Worse => constants::WORSE_AVATAR_SIZE,
+                MediaQuality::Balanced => BALANCED_AVATAR_SIZE,
+                MediaQuality::Worse => WORSE_AVATAR_SIZE,
             };
 
-        let strict_limits = true;
         // max_bytes is 20_000 bytes: Outlook servers don't allow headers larger than 32k.
         // 32 / 4 * 3 = 24k if you account for base64 encoding. To be safe, we reduced this to 20k.
-        if let Some(new_name) =
-            self.recode_to_size(context, blob_abs, img_wh, 20_000, strict_limits)?
-        {
+        if let Some(new_name) = self.recode_to_size(context, blob_abs, img_wh, Some(20_000))? {
             self.name = new_name;
         }
         Ok(())
     }
 
-    pub async fn recode_to_image_size(&mut self, context: &Context) -> Result<()> {
+    pub async fn recode_to_image_size(&self, context: &Context) -> Result<()> {
         let blob_abs = self.to_abs_path();
-        let (img_wh, max_bytes) =
+        if message::guess_msgtype_from_suffix(Path::new(&blob_abs))
+            != Some((Viewtype::Image, "image/jpeg"))
+        {
+            return Ok(());
+        }
+
+        let img_wh =
             match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
                 .unwrap_or_default()
             {
-                MediaQuality::Balanced => (
-                    constants::BALANCED_IMAGE_SIZE,
-                    constants::BALANCED_IMAGE_BYTES,
-                ),
-                MediaQuality::Worse => (constants::WORSE_IMAGE_SIZE, constants::WORSE_IMAGE_BYTES),
+                MediaQuality::Balanced => BALANCED_IMAGE_SIZE,
+                MediaQuality::Worse => WORSE_IMAGE_SIZE,
             };
-        let strict_limits = false;
-        if let Some(new_name) =
-            self.recode_to_size(context, blob_abs, img_wh, max_bytes, strict_limits)?
+
+        if self
+            .recode_to_size(context, blob_abs, img_wh, None)?
+            .is_some()
         {
-            self.name = new_name;
+            return Err(format_err!(
+                "Internal error: recode_to_size(..., None) shouldn't change the name of the image"
+            ));
         }
         Ok(())
     }
 
-    /// If `!strict_limits`, then if `max_bytes` is exceeded, reduce the image to `img_wh` and just
-    /// proceed with the result.
     fn recode_to_size(
         &self,
         context: &Context,
         mut blob_abs: PathBuf,
         mut img_wh: u32,
-        max_bytes: usize,
-        strict_limits: bool,
+        max_bytes: Option<usize>,
     ) -> Result<Option<String>> {
         tokio::task::block_in_place(move || {
-            let mut img = image::open(&blob_abs).context("image decode failure")?;
-            let (nr_bytes, exif) = self.metadata()?;
-            let orientation = exif.as_ref().map(|exif| exif_orientation(exif, context));
+            let mut img = image::open(&blob_abs).context("image recode failure")?;
+            let orientation = self.get_exif_orientation(context);
             let mut encoded = Vec::new();
             let mut changed_name = None;
 
-            img = match orientation {
-                Some(90) => img.rotate90(),
-                Some(180) => img.rotate180(),
-                Some(270) => img.rotate270(),
-                _ => img,
-            };
+            let exceeds_width = img.width() > img_wh || img.height() > img_wh;
 
-            let exceeds_wh = img.width() > img_wh || img.height() > img_wh;
-            let exceeds_max_bytes = nr_bytes > max_bytes as u64;
+            let do_scale =
+                exceeds_width || encoded_img_exceeds_bytes(context, &img, max_bytes, &mut encoded)?;
+            let do_rotate = matches!(orientation, Ok(90) | Ok(180) | Ok(270));
 
-            let fmt = ImageFormat::from_path(&blob_abs);
-            let ofmt = match fmt {
-                Ok(ImageFormat::Png) if !exceeds_max_bytes => ImageOutputFormat::Png,
-                _ => {
-                    let jpeg_quality = 75;
-                    ImageOutputFormat::Jpeg(jpeg_quality)
+            if do_scale || do_rotate {
+                if do_rotate {
+                    img = match orientation {
+                        Ok(90) => img.rotate90(),
+                        Ok(180) => img.rotate180(),
+                        Ok(270) => img.rotate270(),
+                        _ => img,
+                    }
                 }
-            };
-            // We need to rewrite images with Exif to remove metadata such as location,
-            // camera model, etc.
-            //
-            // TODO: Fix lost animation and transparency when recoding using the `image` crate. And
-            // also `Viewtype::Gif` (maybe renamed to `Animation`) should be used for animated
-            // images.
-            let do_scale = exceeds_max_bytes
-                || strict_limits
-                    && (exceeds_wh
-                        || exif.is_some()
-                            && encoded_img_exceeds_bytes(
+
+                if do_scale {
+                    if !exceeds_width {
+                        // The image is already smaller than img_wh, but exceeds max_bytes
+                        // We can directly start with trying to scale down to 2/3 of its current width
+                        img_wh = max(img.width(), img.height()) * 2 / 3
+                    }
+
+                    loop {
+                        let new_img = img.thumbnail(img_wh, img_wh);
+
+                        if encoded_img_exceeds_bytes(context, &new_img, max_bytes, &mut encoded)? {
+                            if img_wh < 20 {
+                                return Err(format_err!(
+                                    "Failed to scale image to below {}B",
+                                    max_bytes.unwrap_or_default()
+                                ));
+                            }
+
+                            img_wh = img_wh * 2 / 3;
+                        } else {
+                            if encoded.is_empty() {
+                                encode_img(&new_img, &mut encoded)?;
+                            }
+
+                            info!(
                                 context,
-                                &img,
-                                ofmt.clone(),
-                                max_bytes,
-                                &mut encoded,
-                            )?);
-
-            if do_scale {
-                if !exceeds_wh {
-                    img_wh = max(img.width(), img.height());
-                    // PNGs and WebPs may be huge because of animation, which is lost by the `image`
-                    // crate when recoding, so don't scale them down.
-                    if matches!(fmt, Ok(ImageFormat::Jpeg)) || !encoded.is_empty() {
-                        img_wh = img_wh * 2 / 3;
-                    }
-                }
-
-                loop {
-                    let new_img = img.thumbnail(img_wh, img_wh);
-
-                    if encoded_img_exceeds_bytes(
-                        context,
-                        &new_img,
-                        ofmt.clone(),
-                        max_bytes,
-                        &mut encoded,
-                    )? && strict_limits
-                    {
-                        if img_wh < 20 {
-                            return Err(format_err!(
-                                "Failed to scale image to below {}B.",
-                                max_bytes,
-                            ));
+                                "Final scaled-down image size: {}B ({}px).",
+                                encoded.len(),
+                                img_wh
+                            );
+                            break;
                         }
-
-                        img_wh = img_wh * 2 / 3;
-                    } else {
-                        info!(
-                            context,
-                            "Final scaled-down image size: {}B ({}px).",
-                            encoded.len(),
-                            img_wh
-                        );
-                        break;
                     }
                 }
-            }
 
-            if do_scale || exif.is_some() {
-                // The file format is JPEG/PNG now, we may have to change the file extension
-                if !matches!(fmt, Ok(ImageFormat::Jpeg))
-                    && matches!(ofmt, ImageOutputFormat::Jpeg(_))
-                {
+                // The file format is JPEG now, we may have to change the file extension
+                if !matches!(ImageFormat::from_path(&blob_abs), Ok(ImageFormat::Jpeg)) {
                     blob_abs = blob_abs.with_extension("jpg");
-                    let file_name = blob_abs.file_name().context("No image file name (???)")?;
+                    let file_name = blob_abs.file_name().context("No avatar file name (???)")?;
                     let file_name = file_name.to_str().context("Filename is no UTF-8 (???)")?;
                     changed_name = Some(format!("$BLOBDIR/{file_name}"));
                 }
 
                 if encoded.is_empty() {
-                    encode_img(&img, ofmt, &mut encoded)?;
+                    encode_img(&img, &mut encoded)?;
                 }
 
                 std::fs::write(&blob_abs, &encoded)
@@ -472,28 +446,23 @@ impl<'a> BlobObject<'a> {
         })
     }
 
-    /// Returns image file size and Exif.
-    pub fn metadata(&self) -> Result<(u64, Option<exif::Exif>)> {
+    pub fn get_exif_orientation(&self, context: &Context) -> Result<i32> {
         let file = std::fs::File::open(self.to_abs_path())?;
-        let len = file.metadata()?.len();
         let mut bufreader = std::io::BufReader::new(&file);
-        let exif = exif::Reader::new().read_from_container(&mut bufreader).ok();
-        Ok((len, exif))
-    }
-}
-
-fn exif_orientation(exif: &exif::Exif, context: &Context) -> i32 {
-    if let Some(orientation) = exif.get_field(exif::Tag::Orientation, exif::In::PRIMARY) {
-        // possible orientation values are described at http://sylvana.net/jpegcrop/exif_orientation.html
-        // we only use rotation, in practise, flipping is not used.
-        match orientation.value.get_uint(0) {
-            Some(3) => return 180,
-            Some(6) => return 90,
-            Some(8) => return 270,
-            other => warn!(context, "Exif orientation value ignored: {other:?}."),
+        let exifreader = exif::Reader::new();
+        let exif = exifreader.read_from_container(&mut bufreader)?;
+        if let Some(orientation) = exif.get_field(exif::Tag::Orientation, exif::In::PRIMARY) {
+            // possible orientation values are described at http://sylvana.net/jpegcrop/exif_orientation.html
+            // we only use rotation, in practise, flipping is not used.
+            match orientation.value.get_uint(0) {
+                Some(3) => return Ok(180),
+                Some(6) => return Ok(90),
+                Some(8) => return Ok(270),
+                other => warn!(context, "Exif orientation value ignored: {other:?}."),
+            }
         }
+        Ok(0)
     }
-    0
 }
 
 impl<'a> fmt::Display for BlobObject<'a> {
@@ -583,35 +552,31 @@ impl<'a> Iterator for BlobDirIter<'a> {
 
 impl FusedIterator for BlobDirIter<'_> {}
 
-fn encode_img(
-    img: &DynamicImage,
-    fmt: ImageOutputFormat,
-    encoded: &mut Vec<u8>,
-) -> anyhow::Result<()> {
+fn encode_img(img: &DynamicImage, encoded: &mut Vec<u8>) -> anyhow::Result<()> {
     encoded.clear();
     let mut buf = Cursor::new(encoded);
-    img.write_to(&mut buf, fmt)?;
+    img.write_to(&mut buf, image::ImageFormat::Jpeg)?;
     Ok(())
 }
-
 fn encoded_img_exceeds_bytes(
     context: &Context,
     img: &DynamicImage,
-    fmt: ImageOutputFormat,
-    max_bytes: usize,
+    max_bytes: Option<usize>,
     encoded: &mut Vec<u8>,
 ) -> anyhow::Result<bool> {
-    encode_img(img, fmt, encoded)?;
-    if encoded.len() > max_bytes {
-        info!(
-            context,
-            "Image size {}B ({}x{}px) exceeds {}B, need to scale down.",
-            encoded.len(),
-            img.width(),
-            img.height(),
-            max_bytes,
-        );
-        return Ok(true);
+    if let Some(max_bytes) = max_bytes {
+        encode_img(img, encoded)?;
+        if encoded.len() > max_bytes {
+            info!(
+                context,
+                "Image size {}B ({}x{}px) exceeds {}B, need to scale down.",
+                encoded.len(),
+                img.width(),
+                img.height(),
+                max_bytes,
+            );
+            return Ok(true);
+        }
     }
     Ok(false)
 }
@@ -624,7 +589,7 @@ mod tests {
 
     use super::*;
     use crate::chat::{self, create_group_chat, ProtectionStatus};
-    use crate::message::{Message, Viewtype};
+    use crate::message::Message;
     use crate::test_utils::{self, TestContext};
 
     fn check_image_size(path: impl AsRef<Path>, width: u32, height: u32) -> image::DynamicImage {
@@ -849,11 +814,7 @@ mod tests {
         assert_eq!(avatar_cfg, avatar_blob.to_str().map(|s| s.to_string()));
 
         check_image_size(avatar_src, 1000, 1000);
-        check_image_size(
-            &avatar_blob,
-            constants::BALANCED_AVATAR_SIZE,
-            constants::BALANCED_AVATAR_SIZE,
-        );
+        check_image_size(&avatar_blob, BALANCED_AVATAR_SIZE, BALANCED_AVATAR_SIZE);
 
         async fn file_size(path_buf: &Path) -> u64 {
             let file = File::open(path_buf).await.unwrap();
@@ -861,8 +822,8 @@ mod tests {
         }
 
         let blob = BlobObject::new_from_path(&t, &avatar_blob).await.unwrap();
-        let strict_limits = true;
-        blob.recode_to_size(&t, blob.to_abs_path(), 1000, 3000, strict_limits)
+
+        blob.recode_to_size(&t, blob.to_abs_path(), 1000, Some(3000))
             .unwrap();
         assert!(file_size(&avatar_blob).await <= 3000);
         assert!(file_size(&avatar_blob).await > 2000);
@@ -889,14 +850,10 @@ mod tests {
         let avatar_cfg = t.get_config(Config::Selfavatar).await.unwrap().unwrap();
         assert_eq!(
             avatar_cfg,
-            avatar_src.with_extension("png").to_str().unwrap()
+            avatar_src.with_extension("jpg").to_str().unwrap()
         );
 
-        check_image_size(
-            avatar_cfg,
-            constants::BALANCED_AVATAR_SIZE,
-            constants::BALANCED_AVATAR_SIZE,
-        );
+        check_image_size(avatar_cfg, BALANCED_AVATAR_SIZE, BALANCED_AVATAR_SIZE);
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -922,29 +879,18 @@ mod tests {
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_recode_image_1() {
         let bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
-        send_image_check_mediaquality(
-            Some("0"),
-            bytes,
-            "jpg",
-            true, // has Exif
-            1000,
-            1000,
-            0,
-            1000,
-            1000,
-        )
-        .await
-        .unwrap();
+        // BALANCED_IMAGE_SIZE > 1000, the original image size, so the image is not scaled down:
+        send_image_check_mediaquality(Some("0"), bytes, 1000, 1000, 0, 1000, 1000)
+            .await
+            .unwrap();
         send_image_check_mediaquality(
             Some("1"),
             bytes,
-            "jpg",
-            true, // has Exif
             1000,
             1000,
             0,
-            1000,
-            1000,
+            WORSE_IMAGE_SIZE,
+            WORSE_IMAGE_SIZE,
         )
         .await
         .unwrap();
@@ -957,87 +903,69 @@ mod tests {
         let img_rotated = send_image_check_mediaquality(
             Some("0"),
             bytes,
-            "jpg",
-            true, // has Exif
             2000,
             1800,
             270,
-            1800,
-            2000,
+            BALANCED_IMAGE_SIZE * 1800 / 2000,
+            BALANCED_IMAGE_SIZE,
         )
         .await
         .unwrap();
         assert_correct_rotation(&img_rotated);
 
         let mut buf = Cursor::new(vec![]);
-        img_rotated.write_to(&mut buf, ImageFormat::Jpeg).unwrap();
+        img_rotated
+            .write_to(&mut buf, image::ImageFormat::Jpeg)
+            .unwrap();
         let bytes = buf.into_inner();
 
+        // Do this in parallel to speed up the test a bit
+        // (it still takes very long though)
+        let bytes2 = bytes.clone();
+        let join_handle = tokio::task::spawn(async move {
+            let img_rotated = send_image_check_mediaquality(
+                Some("0"),
+                &bytes2,
+                BALANCED_IMAGE_SIZE * 1800 / 2000,
+                BALANCED_IMAGE_SIZE,
+                0,
+                BALANCED_IMAGE_SIZE * 1800 / 2000,
+                BALANCED_IMAGE_SIZE,
+            )
+            .await
+            .unwrap();
+            assert_correct_rotation(&img_rotated);
+        });
+
         let img_rotated = send_image_check_mediaquality(
             Some("1"),
             &bytes,
-            "jpg",
-            false, // no Exif
-            1800,
-            2000,
+            BALANCED_IMAGE_SIZE * 1800 / 2000,
+            BALANCED_IMAGE_SIZE,
             0,
-            1800,
-            2000,
+            WORSE_IMAGE_SIZE * 1800 / 2000,
+            WORSE_IMAGE_SIZE,
         )
         .await
         .unwrap();
         assert_correct_rotation(&img_rotated);
+
+        join_handle.await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_recode_image_balanced_png() {
-        let bytes = include_bytes!("../test-data/image/screenshot.png");
+    async fn test_recode_image_3() {
+        let bytes = include_bytes!("../test-data/image/rectangle200x180-rotated.jpg");
+        let img_rotated = send_image_check_mediaquality(Some("0"), bytes, 200, 180, 270, 180, 200)
+            .await
+            .unwrap();
+        assert_correct_rotation(&img_rotated);
 
-        send_image_check_mediaquality(
-            Some("0"),
-            bytes,
-            "png",
-            false, // no Exif
-            1920,
-            1080,
-            0,
-            1920,
-            1080,
-        )
-        .await
-        .unwrap();
-
-        send_image_check_mediaquality(
-            Some("1"),
-            bytes,
-            "png",
-            false, // no Exif
-            1920,
-            1080,
-            0,
-            constants::WORSE_IMAGE_SIZE,
-            constants::WORSE_IMAGE_SIZE * 1080 / 1920,
-        )
-        .await
-        .unwrap();
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_recode_image_huge_jpg() {
-        let bytes = include_bytes!("../test-data/image/screenshot.jpg");
-        send_image_check_mediaquality(
-            Some("0"),
-            bytes,
-            "jpg",
-            true, // has Exif
-            1920,
-            1080,
-            0,
-            constants::BALANCED_IMAGE_SIZE,
-            constants::BALANCED_IMAGE_SIZE * 1080 / 1920,
-        )
-        .await
-        .unwrap();
+        let bytes = include_bytes!("../test-data/image/rectangle200x180-rotated.jpg");
+        let img_rotated = send_image_check_mediaquality(Some("1"), bytes, 200, 180, 270, 180, 200)
+            .await
+            .unwrap();
+        assert_correct_rotation(&img_rotated);
     }
 
     fn assert_correct_rotation(img: &DynamicImage) {
@@ -1057,12 +985,9 @@ mod tests {
         assert_eq!(luma, 0);
     }
 
-    #[allow(clippy::too_many_arguments)]
     async fn send_image_check_mediaquality(
         media_quality_config: Option<&str>,
         bytes: &[u8],
-        extension: &str,
-        has_exif: bool,
         original_width: u32,
         original_height: u32,
         orientation: i32,
@@ -1074,7 +999,7 @@ mod tests {
         alice
             .set_config(Config::MediaQuality, media_quality_config)
             .await?;
-        let file = alice.get_blobdir().join("file").with_extension(extension);
+        let file = alice.get_blobdir().join("file.jpg");
 
         fs::write(&file, &bytes)
             .await
@@ -1082,13 +1007,7 @@ mod tests {
         check_image_size(&file, original_width, original_height);
 
         let blob = BlobObject::new_from_path(&alice, &file).await?;
-        let (_, exif) = blob.metadata()?;
-        if has_exif {
-            let exif = exif.unwrap();
-            assert_eq!(exif_orientation(&exif, &alice), orientation);
-        } else {
-            assert!(exif.is_none());
-        }
+        assert_eq!(blob.get_exif_orientation(&alice).unwrap_or(0), orientation);
 
         let mut msg = Message::new(Viewtype::Image);
         msg.set_file(file.to_str().unwrap(), None);
@@ -1109,8 +1028,7 @@ mod tests {
         let file = bob_msg.get_file(&bob).unwrap();
 
         let blob = BlobObject::new_from_path(&bob, &file).await?;
-        let (_, exif) = blob.metadata()?;
-        assert!(exif.is_none());
+        assert_eq!(blob.get_exif_orientation(&bob).unwrap_or(0), 0);
 
         let img = check_image_size(file, compressed_width, compressed_height);
         Ok(img)

src/chat.rs

@@ -35,9 +35,8 @@ use crate::scheduler::InterruptInfo;
 use crate::smtp::send_msg_to_smtp;
 use crate::stock_str;
 use crate::tools::{
-    buf_compress, create_id, create_outgoing_rfc724_mid, create_smeared_timestamp,
-    create_smeared_timestamps, get_abs_path, gm2local_offset, improve_single_line_input,
-    strip_rtlo_characters, time, IsNoneOrEmpty,
+    create_id, create_outgoing_rfc724_mid, create_smeared_timestamp, create_smeared_timestamps,
+    get_abs_path, gm2local_offset, improve_single_line_input, time, IsNoneOrEmpty,
 };
 use crate::webxdc::WEBXDC_SUFFIX;
 use crate::{location, sql};
@@ -269,26 +268,25 @@ impl ChatId {
         create_protected: ProtectionStatus,
         param: Option<String>,
     ) -> Result<Self> {
-        let grpname = strip_rtlo_characters(grpname);
         let row_id =
             context.sql.insert(
                 "INSERT INTO chats (type, name, grpid, blocked, created_timestamp, protected, param) VALUES(?, ?, ?, ?, ?, ?, ?);",
-                (
+                paramsv![
                     chattype,
-                    &grpname,
+                    grpname,
                     grpid,
                     create_blocked,
                     create_smeared_timestamp(context),
                     create_protected,
                     param.unwrap_or_default(),
-                ),
+                ],
             ).await?;
 
         let chat_id = ChatId::new(u32::try_from(row_id)?);
         info!(
             context,
             "Created group/mailinglist '{}' grpid={} as {}, blocked={}.",
-            &grpname,
+            grpname,
             grpid,
             chat_id,
             create_blocked,
@@ -304,7 +302,7 @@ impl ChatId {
                 "UPDATE contacts
                 SET selfavatar_sent=?
               WHERE id IN(SELECT contact_id FROM chats_contacts WHERE chat_id=?);",
-                (timestamp, self),
+                paramsv![timestamp, self],
             )
             .await?;
         Ok(())
@@ -321,7 +319,7 @@ impl ChatId {
             .sql
             .execute(
                 "UPDATE chats SET blocked=?1 WHERE id=?2 AND blocked != ?1",
-                (new_blocked, self),
+                paramsv![new_blocked, self],
             )
             .await?;
         Ok(count > 0)
@@ -435,7 +433,10 @@ impl ChatId {
 
         context
             .sql
-            .execute("UPDATE chats SET protected=? WHERE id=?;", (protect, self))
+            .execute(
+                "UPDATE chats SET protected=? WHERE id=?;",
+                paramsv![protect, self],
+            )
             .await?;
 
         context.emit_event(EventType::ChatModified(self));
@@ -521,12 +522,12 @@ impl ChatId {
                 if visibility == ChatVisibility::Archived {
                     transaction.execute(
                         "UPDATE msgs SET state=? WHERE chat_id=? AND state=?;",
-                        (MessageState::InNoticed, self, MessageState::InFresh),
+                        paramsv![MessageState::InNoticed, self, MessageState::InFresh],
                     )?;
                 }
                 transaction.execute(
                     "UPDATE chats SET archived=? WHERE id=?;",
-                    (visibility, self),
+                    paramsv![visibility, self],
                 )?;
                 Ok(())
             })
@@ -555,7 +556,7 @@ impl ChatId {
                 .execute(
                     "UPDATE chats SET archived=0 WHERE id=? AND archived=1 \
                 AND NOT(muted_until=-1 OR muted_until>?)",
-                    (self, time()),
+                    paramsv![self, time()],
                 )
                 .await?;
             return Ok(());
@@ -573,7 +574,7 @@ impl ChatId {
                 WHERE state=?
                 AND hidden=0
                 AND chat_id=?",
-                    (MessageState::InFresh, self),
+                    paramsv![MessageState::InFresh, self],
                 )
                 .await?;
             if unread_cnt == 1 {
@@ -584,7 +585,7 @@ impl ChatId {
         }
         context
             .sql
-            .execute("UPDATE chats SET archived=0 WHERE id=?", (self,))
+            .execute("UPDATE chats SET archived=0 WHERE id=?", paramsv![self])
             .await?;
         Ok(())
     }
@@ -613,23 +614,26 @@ impl ChatId {
             .sql
             .execute(
                 "DELETE FROM msgs_mdns WHERE msg_id IN (SELECT id FROM msgs WHERE chat_id=?);",
-                (self,),
+                paramsv![self],
             )
             .await?;
 
         context
             .sql
-            .execute("DELETE FROM msgs WHERE chat_id=?;", (self,))
+            .execute("DELETE FROM msgs WHERE chat_id=?;", paramsv![self])
             .await?;
 
         context
             .sql
-            .execute("DELETE FROM chats_contacts WHERE chat_id=?;", (self,))
+            .execute(
+                "DELETE FROM chats_contacts WHERE chat_id=?;",
+                paramsv![self],
+            )
             .await?;
 
         context
             .sql
-            .execute("DELETE FROM chats WHERE id=?;", (self,))
+            .execute("DELETE FROM chats WHERE id=?;", paramsv![self])
             .await?;
 
         context.emit_msgs_changed_without_ids();
@@ -685,7 +689,7 @@ impl ChatId {
             .sql
             .query_get_value(
                 "SELECT id FROM msgs WHERE chat_id=? AND state=?;",
-                (self, MessageState::OutDraft),
+                paramsv![self, MessageState::OutDraft],
             )
             .await?;
         Ok(msg_id)
@@ -767,14 +771,14 @@ impl ChatId {
                             "UPDATE msgs
                             SET timestamp=?,type=?,txt=?, param=?,mime_in_reply_to=?
                             WHERE id=?;",
-                            (
+                            paramsv![
                                 time(),
                                 msg.viewtype,
                                 msg.text.as_deref().unwrap_or(""),
                                 msg.param.to_string(),
                                 msg.in_reply_to.as_deref().unwrap_or_default(),
-                                msg.id,
-                            ),
+                                msg.id
+                            ],
                         )
                         .await?;
                     return Ok(true);
@@ -798,7 +802,7 @@ impl ChatId {
                  hidden,
                  mime_in_reply_to)
          VALUES (?,?,?, ?,?,?,?,?,?);",
-                (
+                paramsv![
                     self,
                     ContactId::SELF,
                     time(),
@@ -808,7 +812,7 @@ impl ChatId {
                     msg.param.to_string(),
                     1,
                     msg.in_reply_to.as_deref().unwrap_or_default(),
-                ),
+                ],
             )
             .await?;
         msg.id = MsgId::new(row_id.try_into()?);
@@ -821,7 +825,7 @@ impl ChatId {
             .sql
             .count(
                 "SELECT COUNT(*) FROM msgs WHERE hidden=0 AND chat_id=?",
-                (self,),
+                paramsv![self],
             )
             .await?;
         Ok(count)
@@ -864,7 +868,7 @@ impl ChatId {
                 WHERE state=?
                 AND hidden=0
                 AND chat_id=?;",
-                    (MessageState::InFresh, self),
+                    paramsv![MessageState::InFresh, self],
                 )
                 .await?
         };
@@ -874,7 +878,7 @@ impl ChatId {
     pub(crate) async fn get_param(self, context: &Context) -> Result<Params> {
         let res: Option<String> = context
             .sql
-            .query_get_value("SELECT param FROM chats WHERE id=?", (self,))
+            .query_get_value("SELECT param FROM chats WHERE id=?", paramsv![self])
             .await?;
         Ok(res
             .map(|s| s.parse().unwrap_or_default())
@@ -919,13 +923,13 @@ impl ChatId {
         let row = sql
             .query_row_optional(
                 &query,
-                (
+                paramsv![
                     self,
                     MessageState::OutPreparing,
                     MessageState::OutDraft,
                     MessageState::OutPending,
-                    MessageState::OutFailed,
-                ),
+                    MessageState::OutFailed
+                ],
                 f,
             )
             .await?;
@@ -1047,7 +1051,10 @@ impl ChatId {
     pub async fn get_gossiped_timestamp(self, context: &Context) -> Result<i64> {
         let timestamp: Option<i64> = context
             .sql
-            .query_get_value("SELECT gossiped_timestamp FROM chats WHERE id=?;", (self,))
+            .query_get_value(
+                "SELECT gossiped_timestamp FROM chats WHERE id=?;",
+                paramsv![self],
+            )
             .await?;
         Ok(timestamp.unwrap_or_default())
     }
@@ -1070,7 +1077,7 @@ impl ChatId {
             .sql
             .execute(
                 "UPDATE chats SET gossiped_timestamp=? WHERE id=?;",
-                (timestamp, self),
+                paramsv![timestamp, self],
             )
             .await?;
 
@@ -1166,7 +1173,7 @@ impl Chat {
                     c.blocked, c.locations_send_until, c.muted_until, c.protected
              FROM chats c
              WHERE c.id=?;",
-                (chat_id,),
+                paramsv![chat_id],
                 |row| {
                     let c = Chat {
                         id: chat_id,
@@ -1280,7 +1287,7 @@ impl Chat {
             .sql
             .execute(
                 "UPDATE chats SET param=? WHERE id=?",
-                (self.param.to_string(), self.id),
+                paramsv![self.param.to_string(), self.id],
             )
             .await?;
         Ok(())
@@ -1462,7 +1469,7 @@ impl Chat {
                 .sql
                 .query_get_value(
                     "SELECT contact_id FROM chats_contacts WHERE chat_id=?;",
-                    (self.id,),
+                    paramsv![self.id],
                 )
                 .await?
             {
@@ -1543,13 +1550,13 @@ impl Chat {
                     "INSERT INTO locations \
                      (timestamp,from_id,chat_id, latitude,longitude,independent)\
                      VALUES (?,?,?, ?,?,1);",
-                    (
+                    paramsv![
                         timestamp,
                         ContactId::SELF,
                         self.id,
                         msg.param.get_float(Param::SetLatitude).unwrap_or_default(),
                         msg.param.get_float(Param::SetLongitude).unwrap_or_default(),
-                    ),
+                    ],
                 )
                 .await
             {
@@ -1573,12 +1580,7 @@ impl Chat {
             } else {
                 msg.param.get(Param::SendHtml).map(|s| s.to_string())
             };
-            match html {
-                Some(html) => Some(tokio::task::block_in_place(move || {
-                    buf_compress(new_html_mimepart(html).build().as_string().as_bytes())
-                })?),
-                None => None,
-            }
+            html.map(|html| new_html_mimepart(html).build().as_string())
         } else {
             None
         };
@@ -1592,10 +1594,9 @@ impl Chat {
                      SET rfc724_mid=?, chat_id=?, from_id=?, to_id=?, timestamp=?, type=?,
                          state=?, txt=?, subject=?, param=?,
                          hidden=?, mime_in_reply_to=?, mime_references=?, mime_modified=?,
-                         mime_headers=?, mime_compressed=1, location_id=?, ephemeral_timer=?,
-                         ephemeral_timestamp=?
+                         mime_headers=?, location_id=?, ephemeral_timer=?, ephemeral_timestamp=?
                      WHERE id=?;",
-                    params_slice![
+                    paramsv![
                         new_rfc724_mid,
                         self.id,
                         ContactId::SELF,
@@ -1639,12 +1640,11 @@ impl Chat {
                         mime_references,
                         mime_modified,
                         mime_headers,
-                        mime_compressed,
                         location_id,
                         ephemeral_timer,
                         ephemeral_timestamp)
-                        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?,?);",
-                    params_slice![
+                        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);",
+                    paramsv![
                         new_rfc724_mid,
                         self.id,
                         ContactId::SELF,
@@ -1666,7 +1666,6 @@ impl Chat {
                     ],
                 )
                 .await?;
-            context.new_msgs_notify.notify_one();
             msg.id = MsgId::new(u32::try_from(raw_id)?);
 
             maybe_set_logging_xdc(context, msg, self.id).await?;
@@ -1856,7 +1855,7 @@ async fn update_special_chat_name(
             .sql
             .execute(
                 "UPDATE chats SET name=? WHERE id=? AND name!=?",
-                (&name, chat_id, &name),
+                paramsv![name, chat_id, name],
             )
             .await?;
     }
@@ -1919,7 +1918,7 @@ impl ChatIdBlocked {
                   WHERE c.type=100  -- 100 = Chattype::Single
                     AND c.id>9      -- 9 = DC_CHAT_ID_LAST_SPECIAL
                     AND j.contact_id=?;",
-                (contact_id,),
+                paramsv![contact_id],
                 |row| {
                     let id: ChatId = row.get(0)?;
                     let blocked: Blocked = row.get(1)?;
@@ -1970,13 +1969,13 @@ impl ChatIdBlocked {
                     "INSERT INTO chats
                      (type, name, param, blocked, created_timestamp)
                      VALUES(?, ?, ?, ?, ?)",
-                    (
+                    params![
                         Chattype::Single,
                         chat_name,
                         params.to_string(),
                         create_blocked as u8,
-                        create_smeared_timestamp(context),
-                    ),
+                        create_smeared_timestamp(context)
+                    ],
                 )?;
                 let chat_id = ChatId::new(
                     transaction
@@ -1989,7 +1988,7 @@ impl ChatIdBlocked {
                     "INSERT INTO chats_contacts
                  (chat_id, contact_id)
                  VALUES((SELECT last_insert_rowid()), ?)",
-                    (contact_id,),
+                    params![contact_id],
                 )?;
 
                 Ok(chat_id)
@@ -2026,7 +2025,7 @@ async fn prepare_msg_blob(context: &Context, msg: &mut Message) -> Result<()> {
     if msg.viewtype == Viewtype::Text || msg.viewtype == Viewtype::VideochatInvitation {
         // the caller should check if the message text is empty
     } else if msg.viewtype.has_file() {
-        let mut blob = msg
+        let blob = msg
             .param
             .get_blob(Param::File, context, !msg.is_increation())
             .await?
@@ -2149,7 +2148,7 @@ pub async fn is_contact_in_chat(
         .sql
         .exists(
             "SELECT COUNT(*) FROM chats_contacts WHERE chat_id=? AND contact_id=?;",
-            (chat_id, contact_id),
+            paramsv![chat_id, contact_id],
         )
         .await?;
     Ok(exists)
@@ -2201,13 +2200,6 @@ pub async fn send_msg_sync(context: &Context, chat_id: ChatId, msg: &mut Message
 }
 
 async fn send_msg_inner(context: &Context, chat_id: ChatId, msg: &mut Message) -> Result<MsgId> {
-    // protect all system messages againts RTLO attacks
-    if msg.is_system_message() {
-        if let Some(text) = &msg.text {
-            msg.text = Some(strip_rtlo_characters(text.as_ref()));
-        }
-    }
-
     if prepare_send_msg(context, chat_id, msg).await?.is_some() {
         context.emit_msgs_changed(msg.chat_id, msg.id);
 
@@ -2370,12 +2362,12 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
         .insert(
             "INSERT INTO smtp (rfc724_mid, recipients, mime, msg_id)
              VALUES           (?1,         ?2,         ?3,   ?4)",
-            (
+            paramsv![
                 &rendered_msg.rfc724_mid,
                 recipients,
                 &rendered_msg.message,
-                msg_id,
-            ),
+                msg_id
+            ],
         )
         .await?;
     Ok(Some(row_id))
@@ -2541,7 +2533,7 @@ pub async fn get_chat_msgs_ex(
                     OR m.from_id == ?
                     OR m.to_id == ?
                 );",
-                (chat_id, ContactId::INFO, ContactId::INFO),
+                paramsv![chat_id, ContactId::INFO, ContactId::INFO],
                 process_row,
                 process_rows,
             )
@@ -2554,7 +2546,7 @@ pub async fn get_chat_msgs_ex(
                FROM msgs m
               WHERE m.chat_id=?
                 AND m.hidden=0;",
-                (chat_id,),
+                paramsv![chat_id],
                 process_row,
                 process_rows,
             )
@@ -2572,7 +2564,7 @@ pub(crate) async fn marknoticed_chat_if_older_than(
         .sql
         .query_get_value(
             "SELECT MAX(timestamp) FROM msgs WHERE chat_id=?",
-            (chat_id,),
+            paramsv![chat_id],
         )
         .await?
     {
@@ -2622,7 +2614,7 @@ pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()>
             .sql
             .exists(
                 "SELECT COUNT(*) FROM msgs WHERE state=? AND hidden=0 AND chat_id=?;",
-                (MessageState::InFresh, chat_id),
+                paramsv![MessageState::InFresh, chat_id],
             )
             .await?;
         if !exists {
@@ -2637,7 +2629,7 @@ pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()>
               WHERE state=?
                 AND hidden=0
                 AND chat_id=?;",
-                (MessageState::InNoticed, MessageState::InFresh, chat_id),
+                paramsv![MessageState::InNoticed, MessageState::InFresh, chat_id],
             )
             .await?;
     }
@@ -2686,12 +2678,12 @@ pub(crate) async fn mark_old_messages_as_noticed(
             AND hidden=0
             AND chat_id=?
             AND timestamp<=?;",
-                    (
+                    paramsv![
                         MessageState::InNoticed,
                         MessageState::InFresh,
                         msg.chat_id,
-                        msg.sort_timestamp,
-                    ),
+                        msg.sort_timestamp
+                    ],
                 )?;
                 if changed_rows > 0 {
                     changed_chats.push(msg.chat_id);
@@ -2739,7 +2731,7 @@ pub async fn get_chat_media(
                 AND (type=? OR type=? OR type=?)
                 AND hidden=0
               ORDER BY timestamp, id;",
-            (
+            paramsv![
                 chat_id.is_none(),
                 chat_id.unwrap_or_else(|| ChatId::new(0)),
                 DC_CHAT_ID_TRASH,
@@ -2754,7 +2746,7 @@ pub async fn get_chat_media(
                 } else {
                     msg_type
                 },
-            ),
+            ],
             |row| row.get::<_, MsgId>(0),
             |ids| Ok(ids.flatten().collect()),
         )
@@ -2832,7 +2824,7 @@ pub async fn get_chat_contacts(context: &Context, chat_id: ChatId) -> Result<Vec
                       ON c.id=cc.contact_id
               WHERE cc.chat_id=?
               ORDER BY c.id=1, c.last_seen DESC, c.id DESC;",
-            (chat_id,),
+            paramsv![chat_id],
             |row| row.get::<_, ContactId>(0),
             |ids| ids.collect::<Result<Vec<_>, _>>().map_err(Into::into),
         )
@@ -2858,12 +2850,12 @@ pub async fn create_group_chat(
             "INSERT INTO chats
         (type, name, grpid, param, created_timestamp)
         VALUES(?, ?, ?, \'U=1\', ?);",
-            (
+            paramsv![
                 Chattype::Group,
                 chat_name,
                 grpid,
                 create_smeared_timestamp(context),
-            ),
+            ],
         )
         .await?;
 
@@ -2896,7 +2888,7 @@ async fn find_unused_broadcast_list_name(context: &Context) -> Result<String> {
             .sql
             .exists(
                 "SELECT COUNT(*) FROM chats WHERE type=? AND name=?;",
-                (Chattype::Broadcast, &better_name),
+                paramsv![Chattype::Broadcast, better_name],
             )
             .await?
         {
@@ -2916,12 +2908,12 @@ pub async fn create_broadcast_list(context: &Context) -> Result<ChatId> {
             "INSERT INTO chats
         (type, name, grpid, param, created_timestamp)
         VALUES(?, ?, ?, \'U=1\', ?);",
-            (
+            paramsv![
                 Chattype::Broadcast,
                 chat_name,
                 grpid,
                 create_smeared_timestamp(context),
-            ),
+            ],
         )
         .await?;
     let chat_id = ChatId::new(u32::try_from(row_id)?);
@@ -2942,7 +2934,7 @@ pub(crate) async fn add_to_chat_contacts_table(
             for contact_id in contact_ids {
                 transaction.execute(
                     "INSERT OR IGNORE INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)",
-                    (chat_id, contact_id),
+                    paramsv![chat_id, contact_id],
                 )?;
             }
             Ok(())
@@ -2962,7 +2954,7 @@ pub(crate) async fn remove_from_chat_contacts_table(
         .sql
         .execute(
             "DELETE FROM chats_contacts WHERE chat_id=? AND contact_id=?",
-            (chat_id, contact_id),
+            paramsv![chat_id, contact_id],
         )
         .await?;
     Ok(())
@@ -3080,7 +3072,7 @@ pub(crate) async fn shall_attach_selfavatar(context: &Context, chat_id: ChatId)
            FROM chats_contacts cc
            LEFT JOIN contacts c ON c.id=cc.contact_id
           WHERE cc.chat_id=? AND cc.contact_id!=?;",
-            (chat_id, ContactId::SELF),
+            paramsv![chat_id, ContactId::SELF],
             |row| Ok(row.get::<_, i64>(0)),
             |rows| {
                 let mut needs_attach = false;
@@ -3153,7 +3145,7 @@ pub async fn set_muted(context: &Context, chat_id: ChatId, duration: MuteDuratio
         .sql
         .execute(
             "UPDATE chats SET muted_until=? WHERE id=?;",
-            (duration, chat_id),
+            paramsv![duration, chat_id],
         )
         .await
         .context(format!("Failed to set mute duration for {chat_id}"))?;
@@ -3240,7 +3232,10 @@ async fn set_group_explicitly_left(context: &Context, grpid: &str) -> Result<()>
     if !is_group_explicitly_left(context, grpid).await? {
         context
             .sql
-            .execute("INSERT INTO leftgrps (grpid) VALUES(?);", (grpid,))
+            .execute(
+                "INSERT INTO leftgrps (grpid) VALUES(?);",
+                paramsv![grpid.to_string()],
+            )
             .await?;
     }
 
@@ -3250,7 +3245,10 @@ async fn set_group_explicitly_left(context: &Context, grpid: &str) -> Result<()>
 pub(crate) async fn is_group_explicitly_left(context: &Context, grpid: &str) -> Result<bool> {
     let exists = context
         .sql
-        .exists("SELECT COUNT(*) FROM leftgrps WHERE grpid=?;", (grpid,))
+        .exists(
+            "SELECT COUNT(*) FROM leftgrps WHERE grpid=?;",
+            paramsv![grpid],
+        )
         .await?;
     Ok(exists)
 }
@@ -3282,7 +3280,7 @@ pub async fn set_chat_name(context: &Context, chat_id: ChatId, new_name: &str) -
                 .sql
                 .execute(
                     "UPDATE chats SET name=? WHERE id=?;",
-                    (new_name.to_string(), chat_id),
+                    paramsv![new_name.to_string(), chat_id],
                 )
                 .await?;
             if chat.is_promoted()
@@ -3535,7 +3533,7 @@ pub(crate) async fn get_chat_id_by_grpid(
         .sql
         .query_row_optional(
             "SELECT id, blocked, protected FROM chats WHERE grpid=?;",
-            (grpid,),
+            paramsv![grpid],
             |row| {
                 let chat_id = row.get::<_, ChatId>(0)?;
 
@@ -3589,7 +3587,7 @@ pub async fn add_device_msg_with_importance(
             .sql
             .query_get_value(
                 "SELECT MAX(timestamp) FROM msgs WHERE chat_id=?",
-                (chat_id,),
+                paramsv![chat_id],
             )
             .await?
         {
@@ -3614,7 +3612,7 @@ pub async fn add_device_msg_with_importance(
             param,
             rfc724_mid)
             VALUES (?,?,?,?,?,?,?,?,?,?,?);",
-                (
+                paramsv![
                     chat_id,
                     ContactId::DEVICE,
                     ContactId::SELF,
@@ -3626,10 +3624,9 @@ pub async fn add_device_msg_with_importance(
                     msg.text.as_ref().cloned().unwrap_or_default(),
                     msg.param.to_string(),
                     rfc724_mid,
-                ),
+                ],
             )
             .await?;
-        context.new_msgs_notify.notify_one();
 
         msg_id = MsgId::new(u32::try_from(row_id)?);
         if !msg.hidden {
@@ -3640,7 +3637,10 @@ pub async fn add_device_msg_with_importance(
     if let Some(label) = label {
         context
             .sql
-            .execute("INSERT INTO devmsglabels (label) VALUES (?);", (label,))
+            .execute(
+                "INSERT INTO devmsglabels (label) VALUES (?);",
+                paramsv![label.to_string()],
+            )
             .await?;
     }
 
@@ -3667,7 +3667,7 @@ pub async fn was_device_msg_ever_added(context: &Context, label: &str) -> Result
         .sql
         .exists(
             "SELECT COUNT(label) FROM devmsglabels WHERE label=?",
-            (label,),
+            paramsv![label],
         )
         .await?;
 
@@ -3684,7 +3684,10 @@ pub async fn was_device_msg_ever_added(context: &Context, label: &str) -> Result
 pub(crate) async fn delete_and_reset_all_device_msgs(context: &Context) -> Result<()> {
     context
         .sql
-        .execute("DELETE FROM msgs WHERE from_id=?;", (ContactId::DEVICE,))
+        .execute(
+            "DELETE FROM msgs WHERE from_id=?;",
+            paramsv![ContactId::DEVICE],
+        )
         .await?;
     context.sql.execute("DELETE FROM devmsglabels;", ()).await?;
 
@@ -3727,7 +3730,7 @@ pub(crate) async fn add_info_msg_with_cmd(
     context.sql.insert(
         "INSERT INTO msgs (chat_id,from_id,to_id,timestamp,timestamp_sent,timestamp_rcvd,type,state,txt,rfc724_mid,ephemeral_timer, param,mime_in_reply_to)
         VALUES (?,?,?, ?,?,?,?,?, ?,?,?, ?,?);",
-        (
+        paramsv![
             chat_id,
             from_id.unwrap_or(ContactId::INFO),
             ContactId::INFO,
@@ -3741,9 +3744,8 @@ pub(crate) async fn add_info_msg_with_cmd(
             ephemeral_timer,
             param.to_string(),
             parent.map(|msg|msg.rfc724_mid.clone()).unwrap_or_default()
-        )
+        ]
     ).await?;
-    context.new_msgs_notify.notify_one();
 
     let msg_id = MsgId::new(row_id.try_into()?);
     context.emit_msgs_changed(chat_id, msg_id);
@@ -3782,7 +3784,7 @@ pub(crate) async fn update_msg_text_and_timestamp(
         .sql
         .execute(
             "UPDATE msgs SET txt=?, timestamp=? WHERE id=?;",
-            (text, timestamp, msg_id),
+            paramsv![text, timestamp, msg_id],
         )
         .await?;
     context.emit_msgs_changed(chat_id, msg_id);
@@ -3798,7 +3800,6 @@ mod tests {
     use crate::message::delete_msgs;
     use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
-    use tokio::fs;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_chat_info() {
@@ -6098,30 +6099,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_blob_renaming() -> Result<()> {
-        let alice = TestContext::new_alice().await;
-        let bob = TestContext::new_bob().await;
-        let chat_id = create_group_chat(&alice, ProtectionStatus::Unprotected, "Group").await?;
-        add_contact_to_chat(
-            &alice,
-            chat_id,
-            Contact::create(&alice, "bob", "bob@example.net").await?,
-        )
-        .await?;
-        let dir = tempfile::tempdir()?;
-        let file = dir.path().join("harmless_file.\u{202e}txt.exe");
-        fs::write(&file, "aaa").await?;
-        let mut msg = Message::new(Viewtype::File);
-        msg.set_file(file.to_str().unwrap(), None);
-        let msg = bob.recv_msg(&alice.send_msg(chat_id, &mut msg).await).await;
-
-        // the file bob receives should not contain BIDI-control characters
-        assert_eq!(
-            Some("$BLOBDIR/harmless_file.txt.exe"),
-            msg.param.get(Param::File),
-        );
-        Ok(())
-    }
 }

src/chatlist.rs

@@ -137,7 +137,7 @@ impl Chatlist {
                    AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?2)
                  GROUP BY c.id
                  ORDER BY c.archived=?3 DESC, IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                (MessageState::OutDraft, query_contact_id, ChatVisibility::Pinned),
+                paramsv![MessageState::OutDraft, query_contact_id, ChatVisibility::Pinned],
                 process_row,
                 process_rows,
             ).await?
@@ -164,7 +164,7 @@ impl Chatlist {
                    AND c.archived=1
                  GROUP BY c.id
                  ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                    (MessageState::OutDraft,),
+                    paramsv![MessageState::OutDraft],
                     process_row,
                     process_rows,
                 )
@@ -198,7 +198,7 @@ impl Chatlist {
                    AND c.name LIKE ?3
                  GROUP BY c.id
                  ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                    (MessageState::OutDraft, skip_id, str_like_cmd),
+                    paramsv![MessageState::OutDraft, skip_id, str_like_cmd],
                     process_row,
                     process_rows,
                 )
@@ -228,7 +228,7 @@ impl Chatlist {
                    AND NOT c.archived=?4
                  GROUP BY c.id
                  ORDER BY c.id=?5 DESC, c.archived=?6 DESC, IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                (MessageState::OutDraft, skip_id, flag_for_forwarding, ChatVisibility::Archived, sort_id_up, ChatVisibility::Pinned),
+                paramsv![MessageState::OutDraft, skip_id, flag_for_forwarding, ChatVisibility::Archived, sort_id_up, ChatVisibility::Pinned],
                 process_row,
                 process_rows,
             ).await?;
@@ -311,17 +311,13 @@ impl Chatlist {
         };
 
         let (lastmsg, lastcontact) = if let Some(lastmsg_id) = lastmsg_id {
-            let lastmsg = Message::load_from_db(context, lastmsg_id)
-                .await
-                .context("loading message failed")?;
+            let lastmsg = Message::load_from_db(context, lastmsg_id).await?;
             if lastmsg.from_id == ContactId::SELF {
                 (Some(lastmsg), None)
             } else {
                 match chat.typ {
                     Chattype::Group | Chattype::Broadcast | Chattype::Mailinglist => {
-                        let lastcontact = Contact::load_from_db(context, lastmsg.from_id)
-                            .await
-                            .context("loading contact failed")?;
+                        let lastcontact = Contact::load_from_db(context, lastmsg.from_id).await?;
                         (Some(lastmsg), Some(lastcontact))
                     }
                     Chattype::Single | Chattype::Undefined => (Some(lastmsg), None),
@@ -360,31 +356,12 @@ pub async fn get_archived_cnt(context: &Context) -> Result<usize> {
         .sql
         .count(
             "SELECT COUNT(*) FROM chats WHERE blocked!=? AND archived=?;",
-            (Blocked::Yes, ChatVisibility::Archived),
+            paramsv![Blocked::Yes, ChatVisibility::Archived],
         )
         .await?;
     Ok(count)
 }
 
-/// Gets the last message of a chat, the message that would also be displayed in the ChatList
-/// Used for passing to `deltachat::chatlist::Chatlist::get_summary2`
-pub async fn get_last_message_for_chat(
-    context: &Context,
-    chat_id: ChatId,
-) -> Result<Option<MsgId>> {
-    context
-        .sql
-        .query_get_value(
-            "SELECT id
-                FROM msgs
-                WHERE chat_id=?2
-                AND (hidden=0 OR state=?1)
-                ORDER BY timestamp DESC, id DESC LIMIT 1",
-            (MessageState::OutDraft, chat_id),
-        )
-        .await
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/config.rs

@@ -145,7 +145,7 @@ pub enum Config {
     /// If set to "1", on the first time `start_io()` is called after configuring,
     /// the newest existing messages are fetched.
     /// Existing recipients are added to the contact database regardless of this setting.
-    #[strum(props(default = "1"))]
+    #[strum(props(default = "0"))]
     FetchExistingMsgs,
 
     /// If set to "1", then existing messages are considered to be already fetched.
@@ -308,9 +308,6 @@ pub enum Config {
     /// This value is used internally to remember the MsgId of the logging xdc
     #[strum(props(default = "0"))]
     DebugLogging,
-
-    /// Last message processed by the bot.
-    LastMsgId,
 }
 
 impl Context {
@@ -361,11 +358,6 @@ impl Context {
         Ok(self.get_config_parsed(key).await?.unwrap_or_default())
     }
 
-    /// Returns 32-bit unsigned integer configuration value for the given key.
-    pub async fn get_config_u32(&self, key: Config) -> Result<u32> {
-        Ok(self.get_config_parsed(key).await?.unwrap_or_default())
-    }
-
     /// Returns 64-bit signed integer configuration value for the given key.
     pub async fn get_config_i64(&self, key: Config) -> Result<i64> {
         Ok(self.get_config_parsed(key).await?.unwrap_or_default())
@@ -467,12 +459,6 @@ impl Context {
         Ok(())
     }
 
-    /// Set the given config to an unsigned 32-bit integer value.
-    pub async fn set_config_u32(&self, key: Config, value: u32) -> Result<()> {
-        self.set_config(key, Some(&value.to_string())).await?;
-        Ok(())
-    }
-
     /// Set the given config to a boolean value.
     pub async fn set_config_bool(&self, key: Config, value: bool) -> Result<()> {
         self.set_config(key, if value { Some("1") } else { Some("0") })

src/configure.rs

@@ -1,13 +1,4 @@
-//! # Email accounts autoconfiguration process.
-//!
-//! The module provides automatic lookup of configuration
-//! for email providers based on the built-in [provider database],
-//! [Mozilla Thunderbird Autoconfiguration protocol]
-//! and [Outlook's Autodiscover].
-//!
-//! [provider database]: crate::provider
-//! [Mozilla Thunderbird Autoconfiguration protocol]: auto_mozilla
-//! [Outlook's Autodiscover]: auto_outlook
+//! Email accounts autoconfiguration process module.
 
 mod auto_mozilla;
 mod auto_outlook;
@@ -164,9 +155,7 @@ async fn on_configure_completed(
                     Some(stock_str::aeap_explanation_and_link(context, &old_addr, &new_addr).await);
                 chat::add_device_msg(context, None, Some(&mut msg))
                     .await
-                    .context("Cannot add AEAP explanation")
-                    .log_err(context)
-                    .ok();
+                    .ok_or_log_msg(context, "Cannot add AEAP explanation");
             }
         }
     }

src/configure/auto_mozilla.rs

@@ -1,6 +1,6 @@
 //! # Thunderbird's Autoconfiguration implementation
 //!
-//! Documentation: <https://web.archive.org/web/20210624004729/https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration>
+//! Documentation: <https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration>
 use std::io::BufRead;
 use std::str::FromStr;
 

src/constants.rs

@@ -192,15 +192,11 @@ pub const DC_LP_AUTH_FLAGS: i32 = DC_LP_AUTH_OAUTH2 | DC_LP_AUTH_NORMAL;
 /// How many existing messages shall be fetched after configuration.
 pub(crate) const DC_FETCH_EXISTING_MSGS_COUNT: i64 = 100;
 
-// max. weight of images to send w/o recoding
-pub const BALANCED_IMAGE_BYTES: usize = 500_000;
-pub const WORSE_IMAGE_BYTES: usize = 130_000;
-
 // max. width/height of an avatar
 pub(crate) const BALANCED_AVATAR_SIZE: u32 = 256;
 pub(crate) const WORSE_AVATAR_SIZE: u32 = 128;
 
-// max. width/height of images scaled down because of being too huge
+// max. width/height of images
 pub const BALANCED_IMAGE_SIZE: u32 = 1280;
 pub const WORSE_IMAGE_SIZE: u32 = 640;
 

src/contact.rs

@@ -32,10 +32,7 @@ use crate::mimeparser::AvatarAction;
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateVerifiedStatus};
 use crate::sql::{self, params_iter};
-use crate::tools::{
-    duration_to_str, get_abs_path, improve_single_line_input, strip_rtlo_characters, time,
-    EmailAddress,
-};
+use crate::tools::{duration_to_str, get_abs_path, improve_single_line_input, time, EmailAddress};
 use crate::{chat, stock_str};
 
 /// Time during which a contact is considered as seen recently.
@@ -347,7 +344,7 @@ impl Contact {
                 c.authname, c.param, c.status
                FROM contacts c
               WHERE c.id=?;",
-                (contact_id,),
+                paramsv![contact_id],
                 |row| {
                     let name: String = row.get(0)?;
                     let addr: String = row.get(1)?;
@@ -460,7 +457,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE msgs SET state=? WHERE from_id=? AND state=?;",
-                (MessageState::InNoticed, id, MessageState::InFresh),
+                paramsv![MessageState::InNoticed, id, MessageState::InFresh],
             )
             .await?;
         Ok(())
@@ -493,7 +490,7 @@ impl Contact {
                 "SELECT id FROM contacts \
             WHERE addr=?1 COLLATE NOCASE \
             AND id>?2 AND origin>=?3 AND blocked=0;",
-                (&addr_normalized, ContactId::LAST_SPECIAL, min_origin as u32),
+                paramsv![addr_normalized, ContactId::LAST_SPECIAL, min_origin as u32,],
             )
             .await?;
         Ok(id)
@@ -539,7 +536,7 @@ impl Contact {
             return Ok((ContactId::SELF, sth_modified));
         }
 
-        let mut name = strip_rtlo_characters(name);
+        let mut name = name;
         #[allow(clippy::collapsible_if)]
         if origin <= Origin::OutgoingTo {
             // The user may accidentally have written to a "noreply" address with another MUA:
@@ -554,7 +551,7 @@ impl Contact {
                 // For these kind of email addresses, sender and address often don't belong together
                 // (like hocuri <notifications@github.com>). In this example, hocuri shouldn't
                 // be saved as the displayname for notifications@github.com.
-                name = "".to_string();
+                name = "";
             }
         }
 
@@ -608,7 +605,7 @@ impl Contact {
                     transaction
                         .execute(
                             "UPDATE contacts SET name=?, addr=?, origin=?, authname=? WHERE id=?;",
-                            (
+                            paramsv![
                                 new_name,
                                 if update_addr {
                                     addr.to_string()
@@ -626,7 +623,7 @@ impl Contact {
                                     row_authname
                                 },
                                 row_id
-                            ),
+                            ],
                         )?;
 
                     if update_name || update_authname {
@@ -634,7 +631,7 @@ impl Contact {
                         // This is one of the few duplicated data, however, getting the chat list is easier this way.
                         let chat_id: Option<ChatId> = transaction.query_row(
                             "SELECT id FROM chats WHERE type=? AND id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?)",
-                            (Chattype::Single, isize::try_from(row_id)?),
+                            params![Chattype::Single, isize::try_from(row_id)?],
                             |row| {
                                 let chat_id: ChatId = row.get(0)?;
                                 Ok(chat_id)
@@ -648,7 +645,7 @@ impl Contact {
                                     "SELECT addr, name, authname
                                      FROM contacts
                                      WHERE id=?",
-                                     (contact_id,),
+                                     params![contact_id],
                                 |row| {
                                     let addr: String = row.get(0)?;
                                     let name: String = row.get(1)?;
@@ -666,7 +663,7 @@ impl Contact {
 
                             let count = transaction.execute(
                                     "UPDATE chats SET name=?1 WHERE id=?2 AND name!=?1",
-                                    (chat_name, chat_id))?;
+                                    params![chat_name, chat_id])?;
 
                             if count > 0 {
                                 // Chat name updated
@@ -684,7 +681,7 @@ impl Contact {
                     .execute(
                         "INSERT INTO contacts (name, addr, origin, authname)
                          VALUES (?, ?, ?, ?);",
-                         (
+                        params![
                             if update_name {
                                 name.to_string()
                             } else {
@@ -697,7 +694,7 @@ impl Contact {
                             } else {
                                 "".to_string()
                             }
-                        ),
+                        ],
                     )?;
 
                 sth_modified = Modifier::Created;
@@ -798,12 +795,12 @@ impl Contact {
                  ORDER BY c.last_seen DESC, c.id DESC;",
                         sql::repeat_vars(self_addrs.len())
                     ),
-                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
+                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_iterv![
                         ContactId::LAST_SPECIAL,
                         Origin::IncomingReplyTo,
                         s3str_like_cmd,
                         s3str_like_cmd,
-                        if flag_verified_only { 0i32 } else { 1i32 }
+                        if flag_verified_only { 0i32 } else { 1i32 },
                     ])),
                     |row| row.get::<_, ContactId>(0),
                     |ids| {
@@ -850,7 +847,7 @@ impl Contact {
                  ORDER BY last_seen DESC, id DESC;",
                         sql::repeat_vars(self_addrs.len())
                     ),
-                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
+                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_iterv![
                         ContactId::LAST_SPECIAL,
                         Origin::IncomingReplyTo
                     ])),
@@ -883,7 +880,7 @@ impl Contact {
             .transaction(move |transaction| {
                 let mut stmt = transaction
                     .prepare("SELECT name, grpid FROM chats WHERE type=? AND blocked=?")?;
-                let rows = stmt.query_map((Chattype::Mailinglist, Blocked::Yes), |row| {
+                let rows = stmt.query_map(params![Chattype::Mailinglist, Blocked::Yes], |row| {
                     let name: String = row.get(0)?;
                     let grpid: String = row.get(1)?;
                     Ok((name, grpid))
@@ -905,7 +902,7 @@ impl Contact {
                     // Always do an update in case the blocking is reset or name is changed.
                     transaction.execute(
                         "UPDATE contacts SET name=?, origin=?, blocked=1 WHERE addr=?",
-                        (&name, Origin::MailinglistAddress, &grpid),
+                        params![&name, Origin::MailinglistAddress, &grpid],
                     )?;
                 }
                 Ok(())
@@ -920,7 +917,7 @@ impl Contact {
             .sql
             .count(
                 "SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0",
-                (ContactId::LAST_SPECIAL,),
+                paramsv![ContactId::LAST_SPECIAL],
             )
             .await?;
         Ok(count)
@@ -936,7 +933,7 @@ impl Contact {
             .sql
             .query_map(
                 "SELECT id FROM contacts WHERE id>? AND blocked!=0 ORDER BY last_seen DESC, id DESC;",
-                (ContactId::LAST_SPECIAL,),
+                paramsv![ContactId::LAST_SPECIAL],
                 |row| row.get::<_, ContactId>(0),
                 |ids| {
                     ids.collect::<std::result::Result<Vec<_>, _>>()
@@ -1030,12 +1027,12 @@ impl Contact {
                 let deleted_contacts = transaction.execute(
                     "DELETE FROM contacts WHERE id=?
                      AND (SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?)=0;",
-                    (contact_id, contact_id),
+                    paramsv![contact_id, contact_id],
                 )?;
                 if deleted_contacts == 0 {
                     transaction.execute(
                         "UPDATE contacts SET origin=? WHERE id=?;",
-                        (Origin::Hidden, contact_id),
+                        paramsv![Origin::Hidden, contact_id],
                     )?;
                 }
                 Ok(())
@@ -1063,7 +1060,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE contacts SET param=? WHERE id=?",
-                (self.param.to_string(), self.id),
+                paramsv![self.param.to_string(), self.id],
             )
             .await?;
         Ok(())
@@ -1075,7 +1072,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE contacts SET status=? WHERE id=?",
-                (&self.status, self.id),
+                paramsv![self.status, self.id],
             )
             .await?;
         Ok(())
@@ -1195,7 +1192,9 @@ impl Contact {
             if peerstate.verified_key.is_some() {
                 return Ok(VerifiedStatus::BidirectVerified);
             }
-        } else if let Some(peerstate) = Peerstate::from_addr(context, &self.addr).await? {
+        }
+
+        if let Some(peerstate) = Peerstate::from_addr(context, &self.addr).await? {
             if peerstate.verified_key.is_some() {
                 return Ok(VerifiedStatus::BidirectVerified);
             }
@@ -1231,7 +1230,7 @@ impl Contact {
             .sql
             .count(
                 "SELECT COUNT(*) FROM contacts WHERE id>?;",
-                (ContactId::LAST_SPECIAL,),
+                paramsv![ContactId::LAST_SPECIAL],
             )
             .await?;
         Ok(count)
@@ -1245,7 +1244,10 @@ impl Contact {
 
         let exists = context
             .sql
-            .exists("SELECT COUNT(*) FROM contacts WHERE id=?;", (contact_id,))
+            .exists(
+                "SELECT COUNT(*) FROM contacts WHERE id=?;",
+                paramsv![contact_id],
+            )
             .await?;
         Ok(exists)
     }
@@ -1260,7 +1262,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE contacts SET origin=? WHERE id=? AND origin<?;",
-                (origin, contact_id, origin),
+                paramsv![origin, contact_id, origin],
             )
             .await?;
         Ok(())
@@ -1289,20 +1291,18 @@ fn sanitize_name_and_addr(name: &str, addr: &str) -> (String, String) {
     if let Some(captures) = ADDR_WITH_NAME_REGEX.captures(addr.as_ref()) {
         (
             if name.is_empty() {
-                strip_rtlo_characters(
-                    &captures
-                        .get(1)
-                        .map_or("".to_string(), |m| normalize_name(m.as_str())),
-                )
+                captures
+                    .get(1)
+                    .map_or("".to_string(), |m| normalize_name(m.as_str()))
             } else {
-                strip_rtlo_characters(name)
+                name.to_string()
             },
             captures
                 .get(2)
                 .map_or("".to_string(), |m| m.as_str().to_string()),
         )
     } else {
-        (strip_rtlo_characters(name), addr.to_string())
+        (name.to_string(), addr.to_string())
     }
 }
 
@@ -1324,7 +1324,7 @@ async fn set_block_contact(
             .sql
             .execute(
                 "UPDATE contacts SET blocked=? WHERE id=?;",
-                (i32::from(new_blocking), contact_id),
+                paramsv![i32::from(new_blocking), contact_id],
             )
             .await?;
 
@@ -1343,7 +1343,7 @@ WHERE type=? AND id IN (
   SELECT chat_id FROM chats_contacts WHERE contact_id=?
 );
 "#,
-                (new_blocking, Chattype::Single, contact_id),
+                paramsv![new_blocking, Chattype::Single, contact_id],
             )
             .await
             .is_ok()
@@ -1460,7 +1460,7 @@ pub(crate) async fn update_last_seen(
         .sql
         .execute(
             "UPDATE contacts SET last_seen = ?1 WHERE last_seen < ?1 AND id = ?2",
-            (timestamp, contact_id),
+            paramsv![timestamp, contact_id],
         )
         .await?
         > 0
@@ -1489,7 +1489,7 @@ pub fn normalize_name(full_name: &str) -> String {
     match full_name.as_bytes() {
         [b'\'', .., b'\''] | [b'\"', .., b'\"'] | [b'<', .., b'>'] => full_name
             .get(1..full_name.len() - 1)
-            .map_or("".to_string(), |s| s.trim().to_string()),
+            .map_or("".to_string(), |s| s.trim().into()),
         _ => full_name.to_string(),
     }
 }
@@ -1575,7 +1575,7 @@ impl RecentlySeenLoop {
             .query_map(
                 "SELECT id, last_seen FROM contacts
                  WHERE last_seen > ?",
-                (time() - SEEN_RECENTLY_SECONDS,),
+                paramsv![time() - SEEN_RECENTLY_SECONDS],
                 |row| {
                     let contact_id: ContactId = row.get("id")?;
                     let last_seen: i64 = row.get("last_seen")?;

src/context.rs

@@ -11,13 +11,14 @@ use std::time::{Duration, Instant, SystemTime};
 use anyhow::{bail, ensure, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
 use ratelimit::Ratelimit;
-use tokio::sync::{Mutex, Notify, RwLock};
+use tokio::sync::{Mutex, RwLock};
+use tokio::task;
 
 use crate::chat::{get_chat_cnt, ChatId};
 use crate::config::Config;
 use crate::constants::DC_VERSION_STR;
 use crate::contact::Contact;
-use crate::debug_logging::DebugLogging;
+use crate::debug_logging::DebugEventLogData;
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::key::{DcKey, SignedPublicKey};
 use crate::login_param::LoginParam;
@@ -217,11 +218,6 @@ pub struct InnerContext {
     /// IMAP UID resync request.
     pub(crate) resync_request: AtomicBool,
 
-    /// Notify about new messages.
-    ///
-    /// This causes [`Context::wait_next_msgs`] to wake up.
-    pub(crate) new_msgs_notify: Notify,
-
     /// Server ID response if ID capability is supported
     /// and the server returned non-NIL on the inbox connection.
     /// <https://datatracker.ietf.org/doc/html/rfc2971>
@@ -243,10 +239,18 @@ pub struct InnerContext {
     pub(crate) last_error: std::sync::RwLock<String>,
 
     /// If debug logging is enabled, this contains all necessary information
-    ///
-    /// Standard RwLock instead of [`tokio::sync::RwLock`] is used
-    /// because the lock is used from synchronous [`Context::emit_event`].
-    pub(crate) debug_logging: std::sync::RwLock<Option<DebugLogging>>,
+    pub(crate) debug_logging: RwLock<Option<DebugLogging>>,
+}
+
+#[derive(Debug)]
+pub(crate) struct DebugLogging {
+    /// The message containing the logging xdc
+    pub(crate) msg_id: MsgId,
+    /// Handle to the background task responsible for sending
+    pub(crate) loop_handle: task::JoinHandle<()>,
+    /// Channel that log events should be send to
+    /// A background loop will receive and handle them
+    pub(crate) sender: Sender<DebugEventLogData>,
 }
 
 /// The state of ongoing process.
@@ -359,11 +363,6 @@ impl Context {
             blobdir.display()
         );
 
-        let new_msgs_notify = Notify::new();
-        // Notify once immediately to allow processing old messages
-        // without starting I/O.
-        new_msgs_notify.notify_one();
-
         let inner = InnerContext {
             id,
             blobdir,
@@ -380,12 +379,11 @@ impl Context {
             quota: RwLock::new(None),
             quota_update_request: AtomicBool::new(false),
             resync_request: AtomicBool::new(false),
-            new_msgs_notify,
             server_id: RwLock::new(None),
             creation_time: std::time::SystemTime::now(),
             last_full_folder_scan: Mutex::new(None),
             last_error: std::sync::RwLock::new("".to_string()),
-            debug_logging: std::sync::RwLock::new(None),
+            debug_logging: RwLock::new(None),
         };
 
         let ctx = Context {
@@ -440,18 +438,41 @@ impl Context {
 
     /// Emits a single event.
     pub fn emit_event(&self, event: EventType) {
+        if self
+            .debug_logging
+            .try_read()
+            .ok()
+            .map(|inner| inner.is_some())
+            == Some(true)
         {
-            let lock = self.debug_logging.read().expect("RwLock is poisoned");
-            if let Some(debug_logging) = &*lock {
-                debug_logging.log_event(event.clone());
-            }
-        }
+            self.send_log_event(event.clone()).ok();
+        };
         self.events.emit(Event {
             id: self.id,
             typ: event,
         });
     }
 
+    pub(crate) fn send_log_event(&self, event: EventType) -> anyhow::Result<()> {
+        if let Ok(lock) = self.debug_logging.try_read() {
+            if let Some(DebugLogging {
+                msg_id: xdc_id,
+                sender,
+                ..
+            }) = &*lock
+            {
+                let event_data = DebugEventLogData {
+                    time: time(),
+                    msg_id: *xdc_id,
+                    event,
+                };
+
+                sender.try_send(event_data).ok();
+            }
+        }
+        Ok(())
+    }
+
     /// Emits a generic MsgsChanged event (without chat or message id)
     pub fn emit_msgs_changed_without_ids(&self) {
         self.emit_event(EventType::MsgsChanged {
@@ -751,10 +772,6 @@ impl Context {
             "debug_logging",
             self.get_config_int(Config::DebugLogging).await?.to_string(),
         );
-        res.insert(
-            "last_msg_id",
-            self.get_config_int(Config::LastMsgId).await?.to_string(),
-        );
 
         let elapsed = self.creation_time.elapsed();
         res.insert("uptime", duration_to_str(elapsed.unwrap_or_default()));
@@ -787,7 +804,7 @@ impl Context {
                     "   AND NOT(c.muted_until=-1 OR c.muted_until>?)",
                     " ORDER BY m.timestamp DESC,m.id DESC;"
                 ),
-                (MessageState::InFresh, time()),
+                paramsv![MessageState::InFresh, time()],
                 |row| row.get::<_, MsgId>(0),
                 |rows| {
                     let mut list = Vec::new();
@@ -801,66 +818,6 @@ impl Context {
         Ok(list)
     }
 
-    /// Returns a list of messages with database ID higher than requested.
-    ///
-    /// Blocked contacts and chats are excluded,
-    /// but self-sent messages and contact requests are included in the results.
-    pub async fn get_next_msgs(&self) -> Result<Vec<MsgId>> {
-        let last_msg_id = match self.get_config(Config::LastMsgId).await? {
-            Some(s) => MsgId::new(s.parse()?),
-            None => MsgId::new_unset(),
-        };
-
-        let list = self
-            .sql
-            .query_map(
-                "SELECT m.id
-                     FROM msgs m
-                     LEFT JOIN contacts ct
-                            ON m.from_id=ct.id
-                     LEFT JOIN chats c
-                            ON m.chat_id=c.id
-                     WHERE m.id>?
-                       AND m.hidden=0
-                       AND m.chat_id>9
-                       AND ct.blocked=0
-                       AND c.blocked!=1
-                     ORDER BY m.id ASC",
-                (
-                    last_msg_id.to_u32(), // Explicitly convert to u32 because 0 is allowed.
-                ),
-                |row| {
-                    let msg_id: MsgId = row.get(0)?;
-                    Ok(msg_id)
-                },
-                |rows| {
-                    let mut list = Vec::new();
-                    for row in rows {
-                        list.push(row?);
-                    }
-                    Ok(list)
-                },
-            )
-            .await?;
-        Ok(list)
-    }
-
-    /// Returns a list of messages with database ID higher than last marked as seen.
-    ///
-    /// This function is supposed to be used by bot to request messages
-    /// that are not processed yet.
-    ///
-    /// Waits for notification and returns a result.
-    /// Note that the result may be empty if the message is deleted
-    /// shortly after notification or notification is manually triggered
-    /// to interrupt waiting.
-    /// Notification may be manually triggered by calling [`Self::stop_io`].
-    pub async fn wait_next_msgs(&self) -> Result<Vec<MsgId>> {
-        self.new_msgs_notify.notified().await;
-        let list = self.get_next_msgs().await?;
-        Ok(list)
-    }
-
     /// Searches for messages containing the query string.
     ///
     /// If `chat_id` is provided this searches only for messages in this chat, if `chat_id`
@@ -872,10 +829,24 @@ impl Context {
         }
         let str_like_in_text = format!("%{real_query}%");
 
+        let do_query = |query, params| {
+            self.sql.query_map(
+                query,
+                params,
+                |row| row.get::<_, MsgId>("id"),
+                |rows| {
+                    let mut ret = Vec::new();
+                    for id in rows {
+                        ret.push(id?);
+                    }
+                    Ok(ret)
+                },
+            )
+        };
+
         let list = if let Some(chat_id) = chat_id {
-            self.sql
-                .query_map(
-                    "SELECT m.id AS id
+            do_query(
+                "SELECT m.id AS id
                  FROM msgs m
                  LEFT JOIN contacts ct
                         ON m.from_id=ct.id
@@ -884,17 +855,9 @@ impl Context {
                    AND ct.blocked=0
                    AND txt LIKE ?
                  ORDER BY m.timestamp,m.id;",
-                    (chat_id, str_like_in_text),
-                    |row| row.get::<_, MsgId>("id"),
-                    |rows| {
-                        let mut ret = Vec::new();
-                        for id in rows {
-                            ret.push(id?);
-                        }
-                        Ok(ret)
-                    },
-                )
-                .await?
+                paramsv![chat_id, str_like_in_text],
+            )
+            .await?
         } else {
             // For performance reasons results are sorted only by `id`, that is in the order of
             // message reception.
@@ -906,9 +869,8 @@ impl Context {
             // of unwanted results that are discarded moments later, we added `LIMIT 1000`.
             // According to some tests, this limit speeds up eg. 2 character searches by factor 10.
             // The limit is documented and UI may add a hint when getting 1000 results.
-            self.sql
-                .query_map(
-                    "SELECT m.id AS id
+            do_query(
+                "SELECT m.id AS id
                  FROM msgs m
                  LEFT JOIN contacts ct
                         ON m.from_id=ct.id
@@ -920,17 +882,9 @@ impl Context {
                    AND ct.blocked=0
                    AND m.txt LIKE ?
                  ORDER BY m.id DESC LIMIT 1000",
-                    (str_like_in_text,),
-                    |row| row.get::<_, MsgId>("id"),
-                    |rows| {
-                        let mut ret = Vec::new();
-                        for id in rows {
-                            ret.push(id?);
-                        }
-                        Ok(ret)
-                    },
-                )
-                .await?
+                paramsv![str_like_in_text],
+            )
+            .await?
         };
 
         Ok(list)
@@ -1140,7 +1094,7 @@ mod tests {
         t.sql
             .execute(
                 "UPDATE chats SET muted_until=? WHERE id=?;",
-                (time() - 3600, bob.id),
+                paramsv![time() - 3600, bob.id],
             )
             .await
             .unwrap();
@@ -1157,7 +1111,10 @@ mod tests {
         // to test get_fresh_msgs() with invalid mute_until (everything < -1),
         // that results in "muted forever" by definition.
         t.sql
-            .execute("UPDATE chats SET muted_until=-2 WHERE id=?;", (bob.id,))
+            .execute(
+                "UPDATE chats SET muted_until=-2 WHERE id=?;",
+                paramsv![bob.id],
+            )
             .await
             .unwrap();
         let bob = Chat::load_from_db(&t, bob.id).await.unwrap();
@@ -1492,38 +1449,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_get_next_msgs() -> Result<()> {
-        let alice = TestContext::new_alice().await;
-        let bob = TestContext::new_bob().await;
-
-        let alice_chat = alice.create_chat(&bob).await;
-
-        assert!(alice.get_next_msgs().await?.is_empty());
-        assert!(bob.get_next_msgs().await?.is_empty());
-
-        let sent_msg = alice.send_text(alice_chat.id, "Hi Bob").await;
-        let received_msg = bob.recv_msg(&sent_msg).await;
-
-        let bob_next_msg_ids = bob.get_next_msgs().await?;
-        assert_eq!(bob_next_msg_ids.len(), 1);
-        assert_eq!(bob_next_msg_ids.get(0), Some(&received_msg.id));
-
-        bob.set_config_u32(Config::LastMsgId, received_msg.id.to_u32())
-            .await?;
-        assert!(bob.get_next_msgs().await?.is_empty());
-
-        // Next messages include self-sent messages.
-        let alice_next_msg_ids = alice.get_next_msgs().await?;
-        assert_eq!(alice_next_msg_ids.len(), 1);
-        assert_eq!(alice_next_msg_ids.get(0), Some(&sent_msg.sender_msg_id));
-
-        alice
-            .set_config_u32(Config::LastMsgId, sent_msg.sender_msg_id.to_u32())
-            .await?;
-        assert!(alice.get_next_msgs().await?.is_empty());
-
-        Ok(())
-    }
 }

src/debug_logging.rs

@@ -2,41 +2,17 @@
 use crate::{
     chat::ChatId,
     config::Config,
-    context::Context,
+    context::{Context, DebugLogging},
     message::{Message, MsgId, Viewtype},
     param::Param,
-    tools::time,
     webxdc::StatusUpdateItem,
-    EventType,
+    Event, EventType,
 };
-use async_channel::{self as channel, Receiver, Sender};
+use async_channel::{self as channel, Receiver};
 use serde_json::json;
 use std::path::PathBuf;
 use tokio::task;
 
-#[derive(Debug)]
-pub(crate) struct DebugLogging {
-    /// The message containing the logging xdc
-    pub(crate) msg_id: MsgId,
-    /// Handle to the background task responsible for sending
-    pub(crate) loop_handle: task::JoinHandle<()>,
-    /// Channel that log events should be sent to.
-    /// A background loop will receive and handle them.
-    pub(crate) sender: Sender<DebugEventLogData>,
-}
-
-impl DebugLogging {
-    pub(crate) fn log_event(&self, event: EventType) {
-        let event_data = DebugEventLogData {
-            time: time(),
-            msg_id: self.msg_id,
-            event,
-        };
-
-        self.sender.try_send(event_data).ok();
-    }
-}
-
 /// Store all information needed to log an event to a webxdc.
 pub struct DebugEventLogData {
     pub time: i64,
@@ -72,9 +48,12 @@ pub async fn debug_logging_loop(context: &Context, events: Receiver<DebugEventLo
                 eprintln!("Can't log event to webxdc status update: {err:#}");
             }
             Ok(serial) => {
-                context.emit_event(EventType::WebxdcStatusUpdate {
-                    msg_id,
-                    status_update_serial: serial,
+                context.events.emit(Event {
+                    id: context.id,
+                    typ: EventType::WebxdcStatusUpdate {
+                        msg_id,
+                        status_update_serial: serial,
+                    },
                 });
             }
         }
@@ -133,26 +112,24 @@ pub(crate) async fn set_debug_logging_xdc(ctx: &Context, id: Option<MsgId>) -> a
                     Some(msg_id.to_string().as_ref()),
                 )
                 .await?;
-            {
-                let debug_logging = &mut *ctx.debug_logging.write().expect("RwLock is poisoned");
-                match debug_logging {
-                    // Switch logging xdc
-                    Some(debug_logging) => debug_logging.msg_id = msg_id,
-                    // Bootstrap background loop for message forwarding
-                    None => {
-                        let (sender, debug_logging_recv) = channel::bounded(1000);
-                        let loop_handle = {
-                            let ctx = ctx.clone();
-                            task::spawn(async move {
-                                debug_logging_loop(&ctx, debug_logging_recv).await
-                            })
-                        };
-                        *debug_logging = Some(DebugLogging {
-                            msg_id,
-                            loop_handle,
-                            sender,
-                        });
-                    }
+            let debug_logging = &mut *ctx.debug_logging.write().await;
+            match debug_logging {
+                // Switch logging xdc
+                Some(debug_logging) => debug_logging.msg_id = msg_id,
+                // Bootstrap background loop for message forwarding
+                None => {
+                    let (sender, debug_logging_recv) = channel::bounded(1000);
+                    let loop_handle = {
+                        let ctx = ctx.clone();
+                        task::spawn(
+                            async move { debug_logging_loop(&ctx, debug_logging_recv).await },
+                        )
+                    };
+                    *debug_logging = Some(DebugLogging {
+                        msg_id,
+                        loop_handle,
+                        sender,
+                    });
                 }
             }
             info!(ctx, "replacing logging webxdc");
@@ -162,7 +139,7 @@ pub(crate) async fn set_debug_logging_xdc(ctx: &Context, id: Option<MsgId>) -> a
             ctx.sql
                 .set_raw_config(Config::DebugLogging.as_ref(), None)
                 .await?;
-            *ctx.debug_logging.write().expect("RwLock is poisoned") = None;
+            *ctx.debug_logging.write().await = None;
             info!(ctx, "removing logging webxdc");
         }
     }

src/download.rs

@@ -101,7 +101,7 @@ impl MsgId {
             .sql
             .execute(
                 "UPDATE msgs SET download_state=? WHERE id=?;",
-                (download_state, self),
+                paramsv![download_state, self],
             )
             .await?;
         context.emit_event(EventType::MsgsChanged {
@@ -134,7 +134,7 @@ impl Job {
                 .sql
                 .query_row_optional(
                     "SELECT uid, folder FROM imap WHERE rfc724_mid=? AND target=folder",
-                    (&msg.rfc724_mid,),
+                    paramsv![msg.rfc724_mid],
                     |row| {
                         let server_uid: u32 = row.get(0)?;
                         let server_folder: String = row.get(1)?;

src/ephemeral.rs

@@ -174,7 +174,10 @@ impl ChatId {
     pub async fn get_ephemeral_timer(self, context: &Context) -> Result<Timer> {
         let timer = context
             .sql
-            .query_get_value("SELECT ephemeral_timer FROM chats WHERE id=?;", (self,))
+            .query_get_value(
+                "SELECT ephemeral_timer FROM chats WHERE id=?;",
+                paramsv![self],
+            )
             .await?;
         Ok(timer.unwrap_or_default())
     }
@@ -196,7 +199,7 @@ impl ChatId {
                 "UPDATE chats
              SET ephemeral_timer=?
              WHERE id=?;",
-                (timer, self),
+                paramsv![timer, self],
             )
             .await?;
 
@@ -288,7 +291,10 @@ impl MsgId {
     pub(crate) async fn ephemeral_timer(self, context: &Context) -> Result<Timer> {
         let res = match context
             .sql
-            .query_get_value("SELECT ephemeral_timer FROM msgs WHERE id=?", (self,))
+            .query_get_value(
+                "SELECT ephemeral_timer FROM msgs WHERE id=?",
+                paramsv![self],
+            )
             .await?
         {
             None | Some(0) => Timer::Disabled,
@@ -308,7 +314,7 @@ impl MsgId {
                     "UPDATE msgs SET ephemeral_timestamp = ? \
                 WHERE (ephemeral_timestamp == 0 OR ephemeral_timestamp > ?) \
                 AND id = ?",
-                    (ephemeral_timestamp, ephemeral_timestamp, self),
+                    paramsv![ephemeral_timestamp, ephemeral_timestamp, self],
                 )
                 .await?;
             context.scheduler.interrupt_ephemeral_task().await;
@@ -332,8 +338,8 @@ pub(crate) async fn start_ephemeral_timers_msgids(
                 sql::repeat_vars(msg_ids.len())
             ),
             rusqlite::params_from_iter(
-                std::iter::once(&now as &dyn crate::sql::ToSql)
-                    .chain(std::iter::once(&now as &dyn crate::sql::ToSql))
+                std::iter::once(&now as &dyn crate::ToSql)
+                    .chain(std::iter::once(&now as &dyn crate::ToSql))
                     .chain(params_iter(msg_ids)),
             ),
         )
@@ -363,7 +369,7 @@ WHERE
   AND ephemeral_timestamp <= ?
   AND chat_id != ?
 "#,
-            (now, DC_CHAT_ID_TRASH),
+            paramsv![now, DC_CHAT_ID_TRASH],
             |row| {
                 let id: MsgId = row.get("id")?;
                 let chat_id: ChatId = row.get("chat_id")?;
@@ -396,12 +402,12 @@ WHERE
   AND chat_id != ?
   AND chat_id != ?
 "#,
-                (
+                paramsv![
                     threshold_timestamp,
                     DC_CHAT_ID_LAST_SPECIAL,
                     self_chat_id,
-                    device_chat_id,
-                ),
+                    device_chat_id
+                ],
                 |row| {
                     let id: MsgId = row.get("id")?;
                     let chat_id: ChatId = row.get("chat_id")?;
@@ -443,7 +449,7 @@ pub(crate) async fn delete_expired_messages(context: &Context, now: i64) -> Resu
                      SET chat_id=?, txt='', subject='', txt_raw='',
                          mime_headers='', from_id=0, to_id=0, param=''
                      WHERE id=?",
-                        (DC_CHAT_ID_TRASH, msg_id),
+                        params![DC_CHAT_ID_TRASH, msg_id],
                     )?;
 
                     msgs_changed.push((chat_id, msg_id));
@@ -488,7 +494,7 @@ async fn next_delete_device_after_timestamp(context: &Context) -> Result<Option<
                   AND chat_id != ?
                   AND chat_id != ?;
                 "#,
-                (DC_CHAT_ID_TRASH, self_chat_id, device_chat_id),
+                paramsv![DC_CHAT_ID_TRASH, self_chat_id, device_chat_id],
             )
             .await?;
 
@@ -512,7 +518,7 @@ async fn next_expiration_timestamp(context: &Context) -> Option<i64> {
             WHERE ephemeral_timestamp != 0
               AND chat_id != ?;
             "#,
-            (DC_CHAT_ID_TRASH,), // Trash contains already deleted messages, skip them
+            paramsv![DC_CHAT_ID_TRASH], // Trash contains already deleted messages, skip them
         )
         .await
     {
@@ -569,8 +575,7 @@ pub(crate) async fn ephemeral_loop(context: &Context, interrupt_receiver: Receiv
 
         delete_expired_messages(context, time())
             .await
-            .log_err(context)
-            .ok();
+            .ok_or_log(context);
     }
 }
 
@@ -599,12 +604,12 @@ pub(crate) async fn delete_expired_imap_messages(context: &Context) -> Result<()
                       (download_state != 0 AND timestamp < ?) OR
                       (ephemeral_timestamp != 0 AND ephemeral_timestamp <= ?))
              )",
-            (
-                &target,
+            paramsv![
+                target,
                 threshold_timestamp,
                 threshold_timestamp_extended,
                 now,
-            ),
+            ],
         )
         .await?;
 
@@ -629,12 +634,12 @@ pub(crate) async fn start_ephemeral_timers(context: &Context) -> Result<()> {
     WHERE ephemeral_timer > 0 \
     AND ephemeral_timestamp = 0 \
     AND state NOT IN (?, ?, ?)",
-            (
+            paramsv![
                 time(),
                 MessageState::InFresh,
                 MessageState::InNoticed,
-                MessageState::OutDraft,
-            ),
+                MessageState::OutDraft
+            ],
         )
         .await?;
 
@@ -1100,7 +1105,7 @@ mod tests {
             assert!(msg.text.is_none_or_empty(), "{:?}", msg.text);
             let rawtxt: Option<String> = t
                 .sql
-                .query_get_value("SELECT txt_raw FROM msgs WHERE id=?;", (msg_id,))
+                .query_get_value("SELECT txt_raw FROM msgs WHERE id=?;", paramsv![msg_id])
                 .await
                 .unwrap();
             assert!(rawtxt.is_none_or_empty(), "{rawtxt:?}");
@@ -1125,13 +1130,13 @@ mod tests {
             t.sql
                    .execute(
                        "INSERT INTO msgs (id, rfc724_mid, timestamp, ephemeral_timestamp) VALUES (?,?,?,?);",
-                       (id, &message_id, timestamp, ephemeral_timestamp),
+                       paramsv![id, message_id, timestamp, ephemeral_timestamp],
                    )
                    .await?;
             t.sql
                    .execute(
                        "INSERT INTO imap (rfc724_mid, folder, uid, target) VALUES (?,'INBOX',?, 'INBOX');",
-                       (&message_id, id),
+                       paramsv![message_id, id],
                    )
                    .await?;
         }
@@ -1142,7 +1147,7 @@ mod tests {
                     .sql
                     .count(
                         "SELECT COUNT(*) FROM imap WHERE target='' AND rfc724_mid=?",
-                        (id.to_string(),),
+                        paramsv![id.to_string()],
                     )
                     .await?,
                 1
@@ -1153,7 +1158,10 @@ mod tests {
         async fn remove_uid(context: &Context, id: u32) -> Result<()> {
             context
                 .sql
-                .execute("DELETE FROM imap WHERE rfc724_mid=?", (id.to_string(),))
+                .execute(
+                    "DELETE FROM imap WHERE rfc724_mid=?",
+                    paramsv![id.to_string()],
+                )
                 .await?;
             Ok(())
         }

src/events.rs

@@ -1,10 +1,15 @@
 //! # Events specification.
 
+use std::path::PathBuf;
+
 use async_channel::{self as channel, Receiver, Sender, TrySendError};
+use serde::Serialize;
 
-mod payload;
-
-pub use self::payload::EventType;
+use crate::chat::ChatId;
+use crate::contact::ContactId;
+use crate::ephemeral::Timer as EphemeralTimer;
+use crate::message::MsgId;
+use crate::webxdc::StatusUpdateSerial;
 
 /// Event channel.
 #[derive(Debug, Clone)]
@@ -27,9 +32,7 @@ impl Events {
         Self { receiver, sender }
     }
 
-    /// Emits an event into event channel.
-    ///
-    /// If the channel is full, deletes the oldest event first.
+    /// Emits an event.
     pub fn emit(&self, event: Event) {
         match self.sender.try_send(event) {
             Ok(()) => {}
@@ -46,7 +49,7 @@ impl Events {
         }
     }
 
-    /// Creates an event emitter.
+    /// Retrieve the event emitter.
     pub fn get_emitter(&self) -> EventEmitter {
         EventEmitter(self.receiver.clone())
     }
@@ -105,3 +108,251 @@ pub struct Event {
     /// These are documented in `deltachat.h` as the `DC_EVENT_*` constants.
     pub typ: EventType,
 }
+
+/// Event payload.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub enum EventType {
+    /// The library-user may write an informational string to the log.
+    ///
+    /// This event should *not* be reported to the end-user using a popup or something like
+    /// that.
+    Info(String),
+
+    /// Emitted when SMTP connection is established and login was successful.
+    SmtpConnected(String),
+
+    /// Emitted when IMAP connection is established and login was successful.
+    ImapConnected(String),
+
+    /// Emitted when a message was successfully sent to the SMTP server.
+    SmtpMessageSent(String),
+
+    /// Emitted when an IMAP message has been marked as deleted
+    ImapMessageDeleted(String),
+
+    /// Emitted when an IMAP message has been moved
+    ImapMessageMoved(String),
+
+    /// Emitted before going into IDLE on the Inbox folder.
+    ImapInboxIdle,
+
+    /// Emitted when an new file in the $BLOBDIR was created
+    NewBlobFile(String),
+
+    /// Emitted when an file in the $BLOBDIR was deleted
+    DeletedBlobFile(String),
+
+    /// The library-user should write a warning string to the log.
+    ///
+    /// This event should *not* be reported to the end-user using a popup or something like
+    /// that.
+    Warning(String),
+
+    /// The library-user should report an error to the end-user.
+    ///
+    /// As most things are asynchronous, things may go wrong at any time and the user
+    /// should not be disturbed by a dialog or so.  Instead, use a bubble or so.
+    ///
+    /// However, for ongoing processes (eg. configure())
+    /// or for functions that are expected to fail (eg. dc_continue_key_transfer())
+    /// it might be better to delay showing these events until the function has really
+    /// failed (returned false). It should be sufficient to report only the *last* error
+    /// in a messasge box then.
+    Error(String),
+
+    /// An action cannot be performed because the user is not in the group.
+    /// Reported eg. after a call to
+    /// dc_set_chat_name(), dc_set_chat_profile_image(),
+    /// dc_add_contact_to_chat(), dc_remove_contact_from_chat(),
+    /// dc_send_text_msg() or another sending function.
+    ErrorSelfNotInGroup(String),
+
+    /// Messages or chats changed.  One or more messages or chats changed for various
+    /// reasons in the database:
+    /// - Messages sent, received or removed
+    /// - Chats created, deleted or archived
+    /// - A draft has been set
+    ///
+    MsgsChanged {
+        /// Set if only a single chat is affected by the changes, otherwise 0.
+        chat_id: ChatId,
+
+        /// Set if only a single message is affected by the changes, otherwise 0.
+        msg_id: MsgId,
+    },
+
+    /// Reactions for the message changed.
+    ReactionsChanged {
+        /// ID of the chat which the message belongs to.
+        chat_id: ChatId,
+
+        /// ID of the message for which reactions were changed.
+        msg_id: MsgId,
+
+        /// ID of the contact whose reaction set is changed.
+        contact_id: ContactId,
+    },
+
+    /// There is a fresh message. Typically, the user will show an notification
+    /// when receiving this message.
+    ///
+    /// There is no extra #DC_EVENT_MSGS_CHANGED event send together with this event.
+    IncomingMsg {
+        /// ID of the chat where the message is assigned.
+        chat_id: ChatId,
+
+        /// ID of the message.
+        msg_id: MsgId,
+    },
+
+    /// Downloading a bunch of messages just finished.
+    IncomingMsgBunch {
+        /// List of incoming message IDs.
+        msg_ids: Vec<MsgId>,
+    },
+
+    /// Messages were seen or noticed.
+    /// chat id is always set.
+    MsgsNoticed(ChatId),
+
+    /// A single message is sent successfully. State changed from  DC_STATE_OUT_PENDING to
+    /// DC_STATE_OUT_DELIVERED, see dc_msg_get_state().
+    MsgDelivered {
+        /// ID of the chat which the message belongs to.
+        chat_id: ChatId,
+
+        /// ID of the message that was successfully sent.
+        msg_id: MsgId,
+    },
+
+    /// A single message could not be sent. State changed from DC_STATE_OUT_PENDING or DC_STATE_OUT_DELIVERED to
+    /// DC_STATE_OUT_FAILED, see dc_msg_get_state().
+    MsgFailed {
+        /// ID of the chat which the message belongs to.
+        chat_id: ChatId,
+
+        /// ID of the message that could not be sent.
+        msg_id: MsgId,
+    },
+
+    /// A single message is read by the receiver. State changed from DC_STATE_OUT_DELIVERED to
+    /// DC_STATE_OUT_MDN_RCVD, see dc_msg_get_state().
+    MsgRead {
+        /// ID of the chat which the message belongs to.
+        chat_id: ChatId,
+
+        /// ID of the message that was read.
+        msg_id: MsgId,
+    },
+
+    /// Chat changed.  The name or the image of a chat group was changed or members were added or removed.
+    /// Or the verify state of a chat has changed.
+    /// See dc_set_chat_name(), dc_set_chat_profile_image(), dc_add_contact_to_chat()
+    /// and dc_remove_contact_from_chat().
+    ///
+    /// This event does not include ephemeral timer modification, which
+    /// is a separate event.
+    ChatModified(ChatId),
+
+    /// Chat ephemeral timer changed.
+    ChatEphemeralTimerModified {
+        /// Chat ID.
+        chat_id: ChatId,
+
+        /// New ephemeral timer value.
+        timer: EphemeralTimer,
+    },
+
+    /// Contact(s) created, renamed, blocked or deleted.
+    ///
+    /// @param data1 (int) If set, this is the contact_id of an added contact that should be selected.
+    ContactsChanged(Option<ContactId>),
+
+    /// Location of one or more contact has changed.
+    ///
+    /// @param data1 (u32) contact_id of the contact for which the location has changed.
+    ///     If the locations of several contacts have been changed,
+    ///     eg. after calling dc_delete_all_locations(), this parameter is set to `None`.
+    LocationChanged(Option<ContactId>),
+
+    /// Inform about the configuration progress started by configure().
+    ConfigureProgress {
+        /// Progress.
+        ///
+        /// 0=error, 1-999=progress in permille, 1000=success and done
+        progress: usize,
+
+        /// Progress comment or error, something to display to the user.
+        comment: Option<String>,
+    },
+
+    /// Inform about the import/export progress started by imex().
+    ///
+    /// @param data1 (usize) 0=error, 1-999=progress in permille, 1000=success and done
+    /// @param data2 0
+    ImexProgress(usize),
+
+    /// A file has been exported. A file has been written by imex().
+    /// This event may be sent multiple times by a single call to imex().
+    ///
+    /// A typical purpose for a handler of this event may be to make the file public to some system
+    /// services.
+    ///
+    /// @param data2 0
+    ImexFileWritten(PathBuf),
+
+    /// Progress information of a secure-join handshake from the view of the inviter
+    /// (Alice, the person who shows the QR code).
+    ///
+    /// These events are typically sent after a joiner has scanned the QR code
+    /// generated by dc_get_securejoin_qr().
+    SecurejoinInviterProgress {
+        /// ID of the contact that wants to join.
+        contact_id: ContactId,
+
+        /// Progress as:
+        /// 300=vg-/vc-request received, typically shown as "bob@addr joins".
+        /// 600=vg-/vc-request-with-auth received, vg-member-added/vc-contact-confirm sent, typically shown as "bob@addr verified".
+        /// 800=contact added to chat, shown as "bob@addr securely joined GROUP". Only for the verified-group-protocol.
+        /// 1000=Protocol finished for this contact.
+        progress: usize,
+    },
+
+    /// Progress information of a secure-join handshake from the view of the joiner
+    /// (Bob, the person who scans the QR code).
+    /// The events are typically sent while dc_join_securejoin(), which
+    /// may take some time, is executed.
+    SecurejoinJoinerProgress {
+        /// ID of the inviting contact.
+        contact_id: ContactId,
+
+        /// Progress as:
+        /// 400=vg-/vc-request-with-auth sent, typically shown as "alice@addr verified, introducing myself."
+        /// (Bob has verified alice and waits until Alice does the same for him)
+        progress: usize,
+    },
+
+    /// The connectivity to the server changed.
+    /// This means that you should refresh the connectivity view
+    /// and possibly the connectivtiy HTML; see dc_get_connectivity() and
+    /// dc_get_connectivity_html() for details.
+    ConnectivityChanged,
+
+    /// The user's avatar changed.
+    SelfavatarChanged,
+
+    /// Webxdc status update received.
+    WebxdcStatusUpdate {
+        /// Message ID.
+        msg_id: MsgId,
+
+        /// Status update ID.
+        status_update_serial: StatusUpdateSerial,
+    },
+
+    /// Inform that a message containing a webxdc instance has been deleted.
+    WebxdcInstanceDeleted {
+        /// ID of the deleted message.
+        msg_id: MsgId,
+    },
+}

src/events/payload.rs

@@ -1,258 +0,0 @@
-//! # Event payloads.
-
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-
-use crate::chat::ChatId;
-use crate::contact::ContactId;
-use crate::ephemeral::Timer as EphemeralTimer;
-use crate::message::MsgId;
-use crate::webxdc::StatusUpdateSerial;
-
-/// Event payload.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum EventType {
-    /// The library-user may write an informational string to the log.
-    ///
-    /// This event should *not* be reported to the end-user using a popup or something like
-    /// that.
-    Info(String),
-
-    /// Emitted when SMTP connection is established and login was successful.
-    SmtpConnected(String),
-
-    /// Emitted when IMAP connection is established and login was successful.
-    ImapConnected(String),
-
-    /// Emitted when a message was successfully sent to the SMTP server.
-    SmtpMessageSent(String),
-
-    /// Emitted when an IMAP message has been marked as deleted
-    ImapMessageDeleted(String),
-
-    /// Emitted when an IMAP message has been moved
-    ImapMessageMoved(String),
-
-    /// Emitted before going into IDLE on the Inbox folder.
-    ImapInboxIdle,
-
-    /// Emitted when an new file in the $BLOBDIR was created
-    NewBlobFile(String),
-
-    /// Emitted when an file in the $BLOBDIR was deleted
-    DeletedBlobFile(String),
-
-    /// The library-user should write a warning string to the log.
-    ///
-    /// This event should *not* be reported to the end-user using a popup or something like
-    /// that.
-    Warning(String),
-
-    /// The library-user should report an error to the end-user.
-    ///
-    /// As most things are asynchronous, things may go wrong at any time and the user
-    /// should not be disturbed by a dialog or so.  Instead, use a bubble or so.
-    ///
-    /// However, for ongoing processes (eg. configure())
-    /// or for functions that are expected to fail (eg. dc_continue_key_transfer())
-    /// it might be better to delay showing these events until the function has really
-    /// failed (returned false). It should be sufficient to report only the *last* error
-    /// in a messasge box then.
-    Error(String),
-
-    /// An action cannot be performed because the user is not in the group.
-    /// Reported eg. after a call to
-    /// dc_set_chat_name(), dc_set_chat_profile_image(),
-    /// dc_add_contact_to_chat(), dc_remove_contact_from_chat(),
-    /// dc_send_text_msg() or another sending function.
-    ErrorSelfNotInGroup(String),
-
-    /// Messages or chats changed.  One or more messages or chats changed for various
-    /// reasons in the database:
-    /// - Messages sent, received or removed
-    /// - Chats created, deleted or archived
-    /// - A draft has been set
-    ///
-    MsgsChanged {
-        /// Set if only a single chat is affected by the changes, otherwise 0.
-        chat_id: ChatId,
-
-        /// Set if only a single message is affected by the changes, otherwise 0.
-        msg_id: MsgId,
-    },
-
-    /// Reactions for the message changed.
-    ReactionsChanged {
-        /// ID of the chat which the message belongs to.
-        chat_id: ChatId,
-
-        /// ID of the message for which reactions were changed.
-        msg_id: MsgId,
-
-        /// ID of the contact whose reaction set is changed.
-        contact_id: ContactId,
-    },
-
-    /// There is a fresh message. Typically, the user will show an notification
-    /// when receiving this message.
-    ///
-    /// There is no extra #DC_EVENT_MSGS_CHANGED event send together with this event.
-    IncomingMsg {
-        /// ID of the chat where the message is assigned.
-        chat_id: ChatId,
-
-        /// ID of the message.
-        msg_id: MsgId,
-    },
-
-    /// Downloading a bunch of messages just finished.
-    IncomingMsgBunch {
-        /// List of incoming message IDs.
-        msg_ids: Vec<MsgId>,
-    },
-
-    /// Messages were seen or noticed.
-    /// chat id is always set.
-    MsgsNoticed(ChatId),
-
-    /// A single message is sent successfully. State changed from  DC_STATE_OUT_PENDING to
-    /// DC_STATE_OUT_DELIVERED, see dc_msg_get_state().
-    MsgDelivered {
-        /// ID of the chat which the message belongs to.
-        chat_id: ChatId,
-
-        /// ID of the message that was successfully sent.
-        msg_id: MsgId,
-    },
-
-    /// A single message could not be sent. State changed from DC_STATE_OUT_PENDING or DC_STATE_OUT_DELIVERED to
-    /// DC_STATE_OUT_FAILED, see dc_msg_get_state().
-    MsgFailed {
-        /// ID of the chat which the message belongs to.
-        chat_id: ChatId,
-
-        /// ID of the message that could not be sent.
-        msg_id: MsgId,
-    },
-
-    /// A single message is read by the receiver. State changed from DC_STATE_OUT_DELIVERED to
-    /// DC_STATE_OUT_MDN_RCVD, see dc_msg_get_state().
-    MsgRead {
-        /// ID of the chat which the message belongs to.
-        chat_id: ChatId,
-
-        /// ID of the message that was read.
-        msg_id: MsgId,
-    },
-
-    /// Chat changed.  The name or the image of a chat group was changed or members were added or removed.
-    /// Or the verify state of a chat has changed.
-    /// See dc_set_chat_name(), dc_set_chat_profile_image(), dc_add_contact_to_chat()
-    /// and dc_remove_contact_from_chat().
-    ///
-    /// This event does not include ephemeral timer modification, which
-    /// is a separate event.
-    ChatModified(ChatId),
-
-    /// Chat ephemeral timer changed.
-    ChatEphemeralTimerModified {
-        /// Chat ID.
-        chat_id: ChatId,
-
-        /// New ephemeral timer value.
-        timer: EphemeralTimer,
-    },
-
-    /// Contact(s) created, renamed, blocked or deleted.
-    ///
-    /// @param data1 (int) If set, this is the contact_id of an added contact that should be selected.
-    ContactsChanged(Option<ContactId>),
-
-    /// Location of one or more contact has changed.
-    ///
-    /// @param data1 (u32) contact_id of the contact for which the location has changed.
-    ///     If the locations of several contacts have been changed,
-    ///     eg. after calling dc_delete_all_locations(), this parameter is set to `None`.
-    LocationChanged(Option<ContactId>),
-
-    /// Inform about the configuration progress started by configure().
-    ConfigureProgress {
-        /// Progress.
-        ///
-        /// 0=error, 1-999=progress in permille, 1000=success and done
-        progress: usize,
-
-        /// Progress comment or error, something to display to the user.
-        comment: Option<String>,
-    },
-
-    /// Inform about the import/export progress started by imex().
-    ///
-    /// @param data1 (usize) 0=error, 1-999=progress in permille, 1000=success and done
-    /// @param data2 0
-    ImexProgress(usize),
-
-    /// A file has been exported. A file has been written by imex().
-    /// This event may be sent multiple times by a single call to imex().
-    ///
-    /// A typical purpose for a handler of this event may be to make the file public to some system
-    /// services.
-    ///
-    /// @param data2 0
-    ImexFileWritten(PathBuf),
-
-    /// Progress information of a secure-join handshake from the view of the inviter
-    /// (Alice, the person who shows the QR code).
-    ///
-    /// These events are typically sent after a joiner has scanned the QR code
-    /// generated by dc_get_securejoin_qr().
-    SecurejoinInviterProgress {
-        /// ID of the contact that wants to join.
-        contact_id: ContactId,
-
-        /// Progress as:
-        /// 300=vg-/vc-request received, typically shown as "bob@addr joins".
-        /// 600=vg-/vc-request-with-auth received, vg-member-added/vc-contact-confirm sent, typically shown as "bob@addr verified".
-        /// 800=contact added to chat, shown as "bob@addr securely joined GROUP". Only for the verified-group-protocol.
-        /// 1000=Protocol finished for this contact.
-        progress: usize,
-    },
-
-    /// Progress information of a secure-join handshake from the view of the joiner
-    /// (Bob, the person who scans the QR code).
-    /// The events are typically sent while dc_join_securejoin(), which
-    /// may take some time, is executed.
-    SecurejoinJoinerProgress {
-        /// ID of the inviting contact.
-        contact_id: ContactId,
-
-        /// Progress as:
-        /// 400=vg-/vc-request-with-auth sent, typically shown as "alice@addr verified, introducing myself."
-        /// (Bob has verified alice and waits until Alice does the same for him)
-        progress: usize,
-    },
-
-    /// The connectivity to the server changed.
-    /// This means that you should refresh the connectivity view
-    /// and possibly the connectivtiy HTML; see dc_get_connectivity() and
-    /// dc_get_connectivity_html() for details.
-    ConnectivityChanged,
-
-    /// The user's avatar changed.
-    SelfavatarChanged,
-
-    /// Webxdc status update received.
-    WebxdcStatusUpdate {
-        /// Message ID.
-        msg_id: MsgId,
-
-        /// Status update ID.
-        status_update_serial: StatusUpdateSerial,
-    },
-
-    /// Inform that a message containing a webxdc instance has been deleted.
-    WebxdcInstanceDeleted {
-        /// ID of the deleted message.
-        msg_id: MsgId,
-    },
-}

src/imap.rs

@@ -14,7 +14,7 @@ use std::{
 use anyhow::{bail, format_err, Context as _, Result};
 use async_channel::Receiver;
 use async_imap::types::{Fetch, Flag, Name, NameAttribute, UnsolicitedResponse};
-use futures::{StreamExt, TryStreamExt};
+use futures::StreamExt;
 use num_traits::FromPrimitive;
 
 use crate::chat::{self, ChatId, ChatIdBlocked};
@@ -516,7 +516,8 @@ impl Imap {
             .uid_fetch("1:*", RFC724MID_UID)
             .await
             .with_context(|| format!("can't resync folder {folder}"))?;
-        while let Some(fetch) = list.try_next().await? {
+        while let Some(fetch) = list.next().await {
+            let fetch = fetch?;
             let headers = match get_fetch_headers(&fetch) {
                 Ok(headers) => headers,
                 Err(err) => {
@@ -550,7 +551,7 @@ impl Imap {
         context
             .sql
             .transaction(move |transaction| {
-                transaction.execute("DELETE FROM imap WHERE folder=?", (folder,))?;
+                transaction.execute("DELETE FROM imap WHERE folder=?", params![folder])?;
                 for (uid, (rfc724_mid, target)) in &msgs {
                     // This may detect previously undetected moved
                     // messages, so we update server_folder too.
@@ -560,7 +561,7 @@ impl Imap {
                          ON CONFLICT(folder, uid, uidvalidity)
                          DO UPDATE SET rfc724_mid=excluded.rfc724_mid,
                                        target=excluded.target",
-                        (rfc724_mid, folder, uid, uid_validity, target),
+                        params![rfc724_mid, folder, uid, uid_validity, target],
                     )?;
                 }
                 Ok(())
@@ -659,7 +660,7 @@ impl Imap {
                     .context("Error fetching UID")?;
 
                 let mut new_last_seen_uid = None;
-                while let Some(fetch) = list.try_next().await? {
+                while let Some(fetch) = list.next().await.transpose()? {
                     if fetch.message == mailbox.exists && fetch.uid.is_some() {
                         new_last_seen_uid = fetch.uid;
                     }
@@ -676,7 +677,7 @@ impl Imap {
             .sql
             .execute(
                 "DELETE FROM imap WHERE folder=? AND uidvalidity!=?",
-                (&folder, new_uid_validity),
+                paramsv![folder, new_uid_validity],
             )
             .await?;
 
@@ -759,7 +760,7 @@ impl Imap {
                        ON CONFLICT(folder, uid, uidvalidity)
                        DO UPDATE SET rfc724_mid=excluded.rfc724_mid,
                                      target=excluded.target",
-                    (&message_id, &folder, uid, uid_validity, &target),
+                    paramsv![message_id, folder, uid, uid_validity, &target],
                 )
                 .await?;
 
@@ -1050,7 +1051,7 @@ impl Session {
         WHERE folder = ?
         AND target != folder
         ORDER BY target, uid",
-                (folder,),
+                paramsv![folder],
                 |row| {
                     let rowid: i64 = row.get(0)?;
                     let uid: u32 = row.get(1)?;
@@ -1197,11 +1198,8 @@ impl Imap {
             .await
             .context("failed to fetch flags")?;
 
-        while let Some(fetch) = list
-            .try_next()
-            .await
-            .context("failed to get FETCH result")?
-        {
+        while let Some(fetch) = list.next().await {
+            let fetch = fetch.context("failed to get FETCH result")?;
             let uid = if let Some(uid) = fetch.uid {
                 uid
             } else {
@@ -1260,7 +1258,8 @@ impl Imap {
                 .await
                 .context("IMAP Could not fetch")?;
 
-            while let Some(msg) = list.try_next().await? {
+            while let Some(fetch) = list.next().await {
+                let msg = fetch?;
                 match get_fetch_headers(&msg) {
                     Ok(headers) => {
                         if let Some(from) = mimeparser::get_from(&headers) {
@@ -1295,7 +1294,8 @@ impl Imap {
             .context("IMAP could not fetch")?;
 
         let mut msgs = BTreeMap::new();
-        while let Some(msg) = list.try_next().await? {
+        while let Some(fetch) = list.next().await {
+            let msg = fetch?;
             if let Some(msg_uid) = msg.uid {
                 // If the mailbox is not empty, results always include
                 // at least one UID, even if last_seen_uid+1 is past
@@ -1324,15 +1324,16 @@ impl Imap {
         // Fetch last DC_FETCH_EXISTING_MSGS_COUNT (100) messages.
         // Sequence numbers are sequential. If there are 1000 messages in the inbox,
         // we can fetch the sequence numbers 900-1000 and get the last 100 messages.
-        let first = cmp::max(1, exists - DC_FETCH_EXISTING_MSGS_COUNT);
-        let set = format!("{first}:*");
+        let first = cmp::max(1, exists - DC_FETCH_EXISTING_MSGS_COUNT + 1);
+        let set = format!("{first}:{exists}");
         let mut list = session
             .fetch(&set, PREFETCH_FLAGS)
             .await
             .context("IMAP Could not fetch")?;
 
         let mut msgs = BTreeMap::new();
-        while let Some(msg) = list.try_next().await? {
+        while let Some(fetch) = list.next().await {
+            let msg = fetch?;
             if let Some(msg_uid) = msg.uid {
                 msgs.insert((msg.internal_date(), msg_uid), msg);
             }
@@ -1679,7 +1680,8 @@ impl Imap {
         let mut delimiter_is_default = true;
         let mut folder_configs = BTreeMap::new();
 
-        while let Some(folder) = folders.try_next().await? {
+        while let Some(folder) = folders.next().await {
+            let folder = folder?;
             info!(context, "Scanning folder: {:?}", folder);
 
             // Update the delimiter iff there is a different one, but only once.
@@ -1740,37 +1742,17 @@ impl Session {
     /// If this returns `true`, this means that new emails arrived and you should
     /// fetch again, even if you just fetched.
     fn server_sent_unsolicited_exists(&self, context: &Context) -> Result<bool> {
-        use async_imap::imap_proto::Response;
-        use async_imap::imap_proto::ResponseCode;
-        use UnsolicitedResponse::*;
-
         let mut unsolicited_exists = false;
         while let Ok(response) = self.unsolicited_responses.try_recv() {
             match response {
-                Exists(_) => {
+                UnsolicitedResponse::Exists(_) => {
                     info!(
                         context,
                         "Need to fetch again, got unsolicited EXISTS {:?}", response
                     );
                     unsolicited_exists = true;
                 }
-
-                // We are not interested in the following responses and they are are
-                // sent quite frequently, so, we ignore them without logging them
-                Expunge(_) | Recent(_) => {}
-                Other(response_data)
-                    if matches!(
-                        response_data.parsed(),
-                        Response::Fetch { .. }
-                            | Response::Done {
-                                code: Some(ResponseCode::CopyUid(_, _, _)),
-                                ..
-                            }
-                    ) => {}
-
-                _ => {
-                    info!(context, "got unsolicited response {:?}", response)
-                }
+                _ => info!(context, "ignoring unsolicited response {:?}", response),
             }
         }
         Ok(unsolicited_exists)
@@ -2188,7 +2170,7 @@ async fn mark_seen_by_uid(
                    AND uid=?3
                    LIMIT 1
                  )",
-            (&folder, uid_validity, uid),
+            paramsv![&folder, uid_validity, uid],
             |row| {
                 let msg_id: MsgId = row.get(0)?;
                 let chat_id: ChatId = row.get(1)?;
@@ -2204,12 +2186,12 @@ async fn mark_seen_by_uid(
                 "UPDATE msgs SET state=?1
                      WHERE (state=?2 OR state=?3)
                      AND id=?4",
-                (
+                paramsv![
                     MessageState::InSeen,
                     MessageState::InFresh,
                     MessageState::InNoticed,
-                    msg_id,
-                ),
+                    msg_id
+                ],
             )
             .await
             .with_context(|| format!("failed to update msg {msg_id} state"))?
@@ -2239,7 +2221,7 @@ pub(crate) async fn markseen_on_imap_table(context: &Context, message_id: &str)
         .execute(
             "INSERT OR IGNORE INTO imap_markseen (id)
              SELECT id FROM imap WHERE rfc724_mid=?",
-            (message_id,),
+            paramsv![message_id],
         )
         .await?;
     context
@@ -2259,7 +2241,7 @@ pub(crate) async fn set_uid_next(context: &Context, folder: &str, uid_next: u32)
         .execute(
             "INSERT INTO imap_sync (folder, uid_next) VALUES (?,?)
                 ON CONFLICT(folder) DO UPDATE SET uid_next=excluded.uid_next",
-            (folder, uid_next),
+            paramsv![folder, uid_next],
         )
         .await?;
     Ok(())
@@ -2273,7 +2255,10 @@ pub(crate) async fn set_uid_next(context: &Context, folder: &str, uid_next: u32)
 async fn get_uid_next(context: &Context, folder: &str) -> Result<u32> {
     Ok(context
         .sql
-        .query_get_value("SELECT uid_next FROM imap_sync WHERE folder=?;", (folder,))
+        .query_get_value(
+            "SELECT uid_next FROM imap_sync WHERE folder=?;",
+            paramsv![folder],
+        )
         .await?
         .unwrap_or(0))
 }
@@ -2288,7 +2273,7 @@ pub(crate) async fn set_uidvalidity(
         .execute(
             "INSERT INTO imap_sync (folder, uidvalidity) VALUES (?,?)
                 ON CONFLICT(folder) DO UPDATE SET uidvalidity=excluded.uidvalidity",
-            (folder, uidvalidity),
+            paramsv![folder, uidvalidity],
         )
         .await?;
     Ok(())
@@ -2299,7 +2284,7 @@ async fn get_uidvalidity(context: &Context, folder: &str) -> Result<u32> {
         .sql
         .query_get_value(
             "SELECT uidvalidity FROM imap_sync WHERE folder=?;",
-            (folder,),
+            paramsv![folder],
         )
         .await?
         .unwrap_or(0))
@@ -2311,7 +2296,7 @@ pub(crate) async fn set_modseq(context: &Context, folder: &str, modseq: u64) ->
         .execute(
             "INSERT INTO imap_sync (folder, modseq) VALUES (?,?)
                 ON CONFLICT(folder) DO UPDATE SET modseq=excluded.modseq",
-            (folder, modseq),
+            paramsv![folder, modseq],
         )
         .await?;
     Ok(())
@@ -2320,7 +2305,10 @@ pub(crate) async fn set_modseq(context: &Context, folder: &str, modseq: u64) ->
 async fn get_modseq(context: &Context, folder: &str) -> Result<u64> {
     Ok(context
         .sql
-        .query_get_value("SELECT modseq FROM imap_sync WHERE folder=?;", (folder,))
+        .query_get_value(
+            "SELECT modseq FROM imap_sync WHERE folder=?;",
+            paramsv![folder],
+        )
         .await?
         .unwrap_or(0))
 }

src/imap/scan_folders.rs

@@ -70,9 +70,7 @@ impl Imap {
                 loop {
                     self.fetch_move_delete(context, folder.name(), folder_meaning)
                         .await
-                        .context("Can't fetch new msgs in scanned folder")
-                        .log_err(context)
-                        .ok();
+                        .ok_or_log_msg(context, "Can't fetch new msgs in scanned folder");
 
                     let session = self.session.as_mut().context("no session")?;
                     // If the server sent an unsocicited EXISTS during the fetch, we need to fetch again
@@ -107,11 +105,7 @@ impl Imap {
         let list = session
             .list(Some(""), Some("*"))
             .await?
-            .filter_map(|f| async {
-                f.context("list_folders() can't get folder")
-                    .log_err(context)
-                    .ok()
-            });
+            .filter_map(|f| async { f.ok_or_log_msg(context, "list_folders() can't get folder") });
         Ok(list.collect().await)
     }
 }

src/imex.rs

@@ -91,7 +91,7 @@ pub async fn imex(
     let cancel = context.alloc_ongoing().await?;
 
     let res = {
-        let _guard = context.scheduler.pause(context.clone()).await?;
+        let _guard = context.scheduler.pause(context.clone()).await;
         imex_inner(context, what, path, passphrase)
             .race(async {
                 cancel.recv().await.ok();
@@ -759,15 +759,18 @@ async fn export_database(context: &Context, dest: &Path, passphrase: String) ->
         .with_context(|| format!("path {} is not valid unicode", dest.display()))?;
 
     context.sql.set_raw_config_int("backup_time", now).await?;
-    sql::housekeeping(context).await.log_err(context).ok();
+    sql::housekeeping(context).await.ok_or_log(context);
     context
         .sql
         .call_write(|conn| {
-            conn.execute("VACUUM;", ())
+            conn.execute("VACUUM;", params![])
                 .map_err(|err| warn!(context, "Vacuum failed, exporting anyway {err}"))
                 .ok();
-            conn.execute("ATTACH DATABASE ? AS backup KEY ?", (dest, passphrase))
-                .context("failed to attach backup database")?;
+            conn.execute(
+                "ATTACH DATABASE ? AS backup KEY ?",
+                paramsv![dest, passphrase],
+            )
+            .context("failed to attach backup database")?;
             let res = conn
                 .query_row("SELECT sqlcipher_export('backup')", [], |_row| Ok(()))
                 .context("failed to export to attached backup database");

src/imex/transfer.rs

@@ -99,11 +99,11 @@ impl BackupProvider {
 
         // Acquire global "ongoing" mutex.
         let cancel_token = context.alloc_ongoing().await?;
-        let paused_guard = context.scheduler.pause(context.clone()).await?;
+        let paused_guard = context.scheduler.pause(context.clone()).await;
         let context_dir = context
             .get_blobdir()
             .parent()
-            .ok_or_else(|| anyhow!("Context dir not found"))?;
+            .ok_or(anyhow!("Context dir not found"))?;
         let dbfile = context_dir.join(DBFILE_BACKUP_NAME);
         if fs::metadata(&dbfile).await.is_ok() {
             fs::remove_file(&dbfile).await?;
@@ -497,7 +497,7 @@ async fn on_blob(
         let context_dir = context
             .get_blobdir()
             .parent()
-            .ok_or_else(|| anyhow!("Context dir not found"))?;
+            .ok_or(anyhow!("Context dir not found"))?;
         let dbfile = context_dir.join(DBFILE_BACKUP_NAME);
         if fs::metadata(&dbfile).await.is_ok() {
             fs::remove_file(&dbfile).await?;

src/job.rs

@@ -99,7 +99,7 @@ impl Job {
         if self.job_id != 0 {
             context
                 .sql
-                .execute("DELETE FROM jobs WHERE id=?;", (self.job_id as i32,))
+                .execute("DELETE FROM jobs WHERE id=?;", paramsv![self.job_id as i32])
                 .await?;
         }
 
@@ -117,22 +117,22 @@ impl Job {
                 .sql
                 .execute(
                     "UPDATE jobs SET desired_timestamp=?, tries=? WHERE id=?;",
-                    (
+                    paramsv![
                         self.desired_timestamp,
                         i64::from(self.tries),
                         self.job_id as i32,
-                    ),
+                    ],
                 )
                 .await?;
         } else {
             context.sql.execute(
                 "INSERT INTO jobs (added_timestamp, action, foreign_id, desired_timestamp) VALUES (?,?,?,?);",
-                (
+                paramsv![
                     self.added_timestamp,
                     self.action,
                     self.foreign_id,
                     self.desired_timestamp
-                )
+                ]
             ).await?;
         }
 
@@ -277,7 +277,7 @@ WHERE desired_timestamp<=?
 ORDER BY action DESC, added_timestamp
 LIMIT 1;
 "#;
-        params = vec![t];
+        params = paramsv![t];
     } else {
         // processing after call to dc_maybe_network():
         // process _all_ pending jobs that failed before
@@ -289,13 +289,13 @@ WHERE tries>0
 ORDER BY desired_timestamp, action DESC
 LIMIT 1;
 "#;
-        params = vec![];
+        params = paramsv![];
     };
 
     loop {
         let job_res = context
             .sql
-            .query_row_optional(query, rusqlite::params_from_iter(params.clone()), |row| {
+            .query_row_optional(query, params.clone(), |row| {
                 let job = Job {
                     job_id: row.get("id")?,
                     action: row.get("action")?,
@@ -318,14 +318,12 @@ LIMIT 1;
                 // TODO: improve by only doing a single query
                 let id = context
                     .sql
-                    .query_row(query, rusqlite::params_from_iter(params.clone()), |row| {
-                        row.get::<_, i32>(0)
-                    })
+                    .query_row(query, params.clone(), |row| row.get::<_, i32>(0))
                     .await
                     .context("failed to retrieve invalid job ID from the database")?;
                 context
                     .sql
-                    .execute("DELETE FROM jobs WHERE id=?;", (id,))
+                    .execute("DELETE FROM jobs WHERE id=?;", paramsv![id])
                     .await
                     .with_context(|| format!("failed to delete invalid job {id}"))?;
             }
@@ -346,7 +344,7 @@ mod tests {
                 "INSERT INTO jobs
                    (added_timestamp, action, foreign_id, desired_timestamp)
                  VALUES (?, ?, ?, ?);",
-                (
+                paramsv![
                     now,
                     if valid {
                         Action::DownloadMsg as i32
@@ -354,8 +352,8 @@ mod tests {
                         -1
                     },
                     foreign_id,
-                    now,
-                ),
+                    now
+                ],
             )
             .await
             .unwrap();

src/key.rs

@@ -100,7 +100,7 @@ impl DcKey for SignedPublicKey {
                      WHERE addr=?
                        AND is_default=1;
                     "#,
-                    (addr,),
+                    paramsv![addr],
                     |row| {
                         let bytes: Vec<u8> = row.get(0)?;
                         Ok(bytes)
@@ -240,7 +240,7 @@ pub(crate) async fn load_keypair(
          WHERE addr=?1
            AND is_default=1;
         "#,
-            (addr,),
+            paramsv![addr],
             |row| {
                 let pub_bytes: Vec<u8> = row.get(0)?;
                 let sec_bytes: Vec<u8> = row.get(1)?;
@@ -297,7 +297,7 @@ pub async fn store_self_keypair(
             transaction
                 .execute(
                     "DELETE FROM keypairs WHERE public_key=? OR private_key=?;",
-                    (&public_key, &secret_key),
+                    paramsv![public_key, secret_key],
                 )
                 .context("failed to remove old use of key")?;
             if default == KeyPairUse::Default {
@@ -317,7 +317,7 @@ pub async fn store_self_keypair(
                 .execute(
                     "INSERT INTO keypairs (addr, is_default, public_key, private_key, created)
                 VALUES (?,?,?,?,?);",
-                    (addr, is_default, &public_key, &secret_key, t),
+                    paramsv![addr, is_default, public_key, secret_key, t],
                 )
                 .context("failed to insert keypair")?;
 

src/lib.rs

@@ -35,6 +35,11 @@ extern crate rusqlite;
 #[macro_use]
 extern crate strum_macros;
 
+#[allow(missing_docs)]
+pub trait ToSql: rusqlite::ToSql + Send + Sync {}
+
+impl<T: rusqlite::ToSql + Send + Sync> ToSql for T {}
+
 #[macro_use]
 pub mod log;
 
@@ -65,7 +70,6 @@ mod e2ee;
 pub mod ephemeral;
 mod imap;
 pub mod imex;
-pub mod release;
 mod scheduler;
 #[macro_use]
 mod job;

src/location.rs

@@ -5,6 +5,7 @@ use std::time::Duration;
 
 use anyhow::{ensure, Context as _, Result};
 use async_channel::Receiver;
+use bitflags::bitflags;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText};
 use tokio::time::timeout;
 
@@ -77,15 +78,16 @@ pub struct Kml {
     pub curr: Location,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-enum KmlTag {
-    #[default]
-    Undefined,
-    Placemark,
-    PlacemarkTimestamp,
-    PlacemarkTimestampWhen,
-    PlacemarkPoint,
-    PlacemarkPointCoordinates,
+bitflags! {
+    #[derive(Default)]
+    struct KmlTag: i32 {
+        const UNDEFINED = 0x00;
+        const PLACEMARK = 0x01;
+        const TIMESTAMP = 0x02;
+        const WHEN = 0x04;
+        const POINT = 0x08;
+        const COORDINATES = 0x10;
+    }
 }
 
 impl Kml {
@@ -126,14 +128,12 @@ impl Kml {
     }
 
     fn text_cb(&mut self, event: &BytesText) {
-        if self.tag == KmlTag::PlacemarkTimestampWhen
-            || self.tag == KmlTag::PlacemarkPointCoordinates
-        {
+        if self.tag.contains(KmlTag::WHEN) || self.tag.contains(KmlTag::COORDINATES) {
             let val = event.unescape().unwrap_or_default();
 
             let val = val.replace(['\n', '\r', '\t', ' '], "");
 
-            if self.tag == KmlTag::PlacemarkTimestampWhen && val.len() >= 19 {
+            if self.tag.contains(KmlTag::WHEN) && val.len() >= 19 {
                 // YYYY-MM-DDTHH:MM:SSZ
                 // 0   4  7  10 13 16 19
                 match chrono::NaiveDateTime::parse_from_str(&val, "%Y-%m-%dT%H:%M:%SZ") {
@@ -147,7 +147,7 @@ impl Kml {
                         self.curr.timestamp = time();
                     }
                 }
-            } else if self.tag == KmlTag::PlacemarkPointCoordinates {
+            } else if self.tag.contains(KmlTag::COORDINATES) {
                 let parts = val.splitn(2, ',').collect::<Vec<_>>();
                 if let [longitude, latitude] = &parts[..] {
                     self.curr.longitude = longitude.parse().unwrap_or_default();
@@ -162,41 +162,17 @@ impl Kml {
             .trim()
             .to_lowercase();
 
-        match self.tag {
-            KmlTag::PlacemarkTimestampWhen => {
-                if tag == "when" {
-                    self.tag = KmlTag::PlacemarkTimestamp
-                }
+        if tag == "placemark" {
+            if self.tag.contains(KmlTag::PLACEMARK)
+                && 0 != self.curr.timestamp
+                && 0. != self.curr.latitude
+                && 0. != self.curr.longitude
+            {
+                self.locations
+                    .push(std::mem::replace(&mut self.curr, Location::new()));
             }
-            KmlTag::PlacemarkTimestamp => {
-                if tag == "timestamp" {
-                    self.tag = KmlTag::Placemark
-                }
-            }
-            KmlTag::PlacemarkPointCoordinates => {
-                if tag == "coordinates" {
-                    self.tag = KmlTag::PlacemarkPoint
-                }
-            }
-            KmlTag::PlacemarkPoint => {
-                if tag == "point" {
-                    self.tag = KmlTag::Placemark
-                }
-            }
-            KmlTag::Placemark => {
-                if tag == "placemark" {
-                    if 0 != self.curr.timestamp
-                        && 0. != self.curr.latitude
-                        && 0. != self.curr.longitude
-                    {
-                        self.locations
-                            .push(std::mem::replace(&mut self.curr, Location::new()));
-                    }
-                    self.tag = KmlTag::Undefined;
-                }
-            }
-            KmlTag::Undefined => {}
-        }
+            self.tag = KmlTag::UNDEFINED;
+        };
     }
 
     fn starttag_cb<B: std::io::BufRead>(
@@ -220,19 +196,19 @@ impl Kml {
                     .map(|a| a.into_owned());
             }
         } else if tag == "placemark" {
-            self.tag = KmlTag::Placemark;
+            self.tag = KmlTag::PLACEMARK;
             self.curr.timestamp = 0;
             self.curr.latitude = 0.0;
             self.curr.longitude = 0.0;
             self.curr.accuracy = 0.0
-        } else if tag == "timestamp" && self.tag == KmlTag::Placemark {
-            self.tag = KmlTag::PlacemarkTimestamp;
-        } else if tag == "when" && self.tag == KmlTag::PlacemarkTimestamp {
-            self.tag = KmlTag::PlacemarkTimestampWhen;
-        } else if tag == "point" && self.tag == KmlTag::Placemark {
-            self.tag = KmlTag::PlacemarkPoint;
-        } else if tag == "coordinates" && self.tag == KmlTag::PlacemarkPoint {
-            self.tag = KmlTag::PlacemarkPointCoordinates;
+        } else if tag == "timestamp" && self.tag.contains(KmlTag::PLACEMARK) {
+            self.tag = KmlTag::PLACEMARK | KmlTag::TIMESTAMP
+        } else if tag == "when" && self.tag.contains(KmlTag::TIMESTAMP) {
+            self.tag = KmlTag::PLACEMARK | KmlTag::TIMESTAMP | KmlTag::WHEN
+        } else if tag == "point" && self.tag.contains(KmlTag::PLACEMARK) {
+            self.tag = KmlTag::PLACEMARK | KmlTag::POINT
+        } else if tag == "coordinates" && self.tag.contains(KmlTag::POINT) {
+            self.tag = KmlTag::PLACEMARK | KmlTag::POINT | KmlTag::COORDINATES;
             if let Some(acc) = event.attributes().find(|attr| {
                 attr.as_ref()
                     .map(|a| {
@@ -271,11 +247,11 @@ pub async fn send_locations_to_chat(
          SET locations_send_begin=?,        \
          locations_send_until=?  \
          WHERE id=?",
-            (
+            paramsv![
                 if 0 != seconds { now } else { 0 },
                 if 0 != seconds { now + seconds } else { 0 },
                 chat_id,
-            ),
+            ],
         )
         .await?;
     if 0 != seconds && !is_sending_locations_before {
@@ -310,7 +286,7 @@ pub async fn is_sending_locations_to_chat(
                 .sql
                 .exists(
                     "SELECT COUNT(id) FROM chats  WHERE id=?  AND locations_send_until>?;",
-                    (chat_id, time()),
+                    paramsv![chat_id, time()],
                 )
                 .await?
         }
@@ -319,7 +295,7 @@ pub async fn is_sending_locations_to_chat(
                 .sql
                 .exists(
                     "SELECT COUNT(id) FROM chats  WHERE locations_send_until>?;",
-                    (time(),),
+                    paramsv![time()],
                 )
                 .await?
         }
@@ -338,7 +314,7 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
         .sql
         .query_map(
             "SELECT id FROM chats WHERE locations_send_until>?;",
-            (time(),),
+            paramsv![time()],
             |row| row.get::<_, i32>(0),
             |chats| {
                 chats
@@ -352,14 +328,14 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
             if let Err(err) = context.sql.execute(
                     "INSERT INTO locations  \
                      (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);",
-                     (
+                    paramsv![
                         latitude,
                         longitude,
                         accuracy,
                         time(),
                         chat_id,
                         ContactId::SELF,
-                    )
+                    ]
             ).await {
                 warn!(context, "failed to store location {:#}", err);
             } else {
@@ -404,14 +380,14 @@ pub async fn get_range(
              AND (? OR l.from_id=?) \
              AND (l.independent=1 OR (l.timestamp>=? AND l.timestamp<=?)) \
              ORDER BY l.timestamp DESC, l.id DESC, msg_id DESC;",
-            (
+            paramsv![
                 disable_chat_id,
                 chat_id,
                 disable_contact_id,
                 contact_id as i32,
                 timestamp_from,
                 timestamp_to,
-            ),
+            ],
             |row| {
                 let msg_id = row.get(6)?;
                 let txt: String = row.get(9)?;
@@ -471,7 +447,7 @@ pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)
 
     let (locations_send_begin, locations_send_until, locations_last_sent) = context.sql.query_row(
         "SELECT locations_send_begin, locations_send_until, locations_last_sent  FROM chats  WHERE id=?;",
-        (chat_id,), |row| {
+        paramsv![chat_id], |row| {
             let send_begin: i64 = row.get(0)?;
             let send_until: i64 = row.get(1)?;
             let last_sent: i64 = row.get(2)?;
@@ -500,12 +476,12 @@ pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)
              AND independent=0 \
              GROUP BY timestamp \
              ORDER BY timestamp;",
-             (
+                paramsv![
                     ContactId::SELF,
                     locations_send_begin,
                     locations_last_sent,
                     ContactId::SELF
-                ),
+                ],
                 |row| {
                     let location_id: i32 = row.get(0)?;
                     let latitude: f64 = row.get(1)?;
@@ -575,7 +551,7 @@ pub async fn set_kml_sent_timestamp(
         .sql
         .execute(
             "UPDATE chats SET locations_last_sent=? WHERE id=?;",
-            (timestamp, chat_id),
+            paramsv![timestamp, chat_id],
         )
         .await?;
     Ok(())
@@ -587,7 +563,7 @@ pub async fn set_msg_location_id(context: &Context, msg_id: MsgId, location_id:
         .sql
         .execute(
             "UPDATE msgs SET location_id=? WHERE id=?;",
-            (location_id, msg_id),
+            paramsv![location_id, msg_id],
         )
         .await?;
 
@@ -629,10 +605,10 @@ pub(crate) async fn save(
                     .prepare_cached("SELECT id FROM locations WHERE timestamp=? AND from_id=?")?;
                 let mut stmt_insert = conn.prepare_cached(stmt_insert)?;
 
-                let exists = stmt_test.exists((timestamp, contact_id))?;
+                let exists = stmt_test.exists(paramsv![timestamp, contact_id])?;
 
                 if independent || !exists {
-                    stmt_insert.execute((
+                    stmt_insert.execute(paramsv![
                         timestamp,
                         contact_id,
                         chat_id,
@@ -640,7 +616,7 @@ pub(crate) async fn save(
                         longitude,
                         accuracy,
                         independent,
-                    ))?;
+                    ])?;
 
                     if timestamp > newest_timestamp {
                         // okay to drop, as we use cached prepared statements
@@ -729,7 +705,7 @@ async fn maybe_send_locations(context: &Context) -> Result<Option<u64>> {
      AND timestamp>=? \
      AND timestamp>? \
      AND independent=0",
-                    (ContactId::SELF, locations_send_begin, locations_last_sent),
+                    paramsv![ContactId::SELF, locations_send_begin, locations_last_sent,],
                 )
                 .await?;
 
@@ -781,7 +757,7 @@ async fn maybe_send_locations(context: &Context) -> Result<Option<u64>> {
                     "UPDATE chats \
                          SET locations_send_begin=0, locations_send_until=0 \
                          WHERE id=?",
-                    (chat_id,),
+                    paramsv![chat_id],
                 )
                 .await
                 .context("failed to disable location streaming")?;

src/log.rs

@@ -65,6 +65,9 @@ pub trait LogExt<T, E>
 where
     Self: std::marker::Sized,
 {
+    #[track_caller]
+    fn log_err_inner(self, context: &Context, msg: Option<&str>) -> Result<T, E>;
+
     /// Emits a warning if the receiver contains an Err value.
     ///
     /// Thanks to the [track_caller](https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html#track_caller)
@@ -73,23 +76,73 @@ where
     /// Unfortunately, the track_caller feature does not work on async functions (as of Rust 1.50).
     /// Once it is, you can add `#[track_caller]` to helper functions that use one of the log helpers here
     /// so that the location of the caller can be seen in the log. (this won't work with the macros,
-    /// like warn!(), since the file!() and line!() macros don't work with track_caller)
+    /// like warn!(), since the file!() and line!() macros don't work with track_caller)  
     /// See <https://github.com/rust-lang/rust/issues/78840> for progress on this.
     #[track_caller]
-    fn log_err(self, context: &Context) -> Result<T, E>;
+    fn log_err(self, context: &Context, msg: &str) -> Result<T, E> {
+        self.log_err_inner(context, Some(msg))
+    }
+
+    /// Emits a warning if the receiver contains an Err value and returns an [`Option<T>`].
+    ///
+    /// Example:
+    /// ```text
+    /// if let Err(e) = do_something() {
+    ///     warn!(context, "{:#}", e);
+    /// }
+    /// ```
+    /// is equivalent to:
+    /// ```text
+    /// do_something().ok_or_log(context);
+    /// ```
+    ///
+    /// For a note on the `track_caller` feature, see the doc comment on `log_err()`.
+    #[track_caller]
+    fn ok_or_log(self, context: &Context) -> Option<T> {
+        self.log_err_inner(context, None).ok()
+    }
+
+    /// Like `ok_or_log()`, but you can pass an extra message that is prepended in the log.
+    ///
+    /// Example:
+    /// ```text
+    /// if let Err(e) = do_something() {
+    ///     warn!(context, "Something went wrong: {:#}", e);
+    /// }
+    /// ```
+    /// is equivalent to:
+    /// ```text
+    /// do_something().ok_or_log_msg(context, "Something went wrong");
+    /// ```
+    /// and is also equivalent to:
+    /// ```text
+    /// use anyhow::Context as _;
+    /// do_something().context("Something went wrong").ok_or_log(context);
+    /// ```
+    ///
+    /// For a note on the `track_caller` feature, see the doc comment on `log_err()`.
+    #[track_caller]
+    fn ok_or_log_msg(self, context: &Context, msg: &'static str) -> Option<T> {
+        self.log_err_inner(context, Some(msg)).ok()
+    }
 }
 
 impl<T, E: std::fmt::Display> LogExt<T, E> for Result<T, E> {
     #[track_caller]
-    fn log_err(self, context: &Context) -> Result<T, E> {
+    fn log_err_inner(self, context: &Context, msg: Option<&str>) -> Result<T, E> {
         if let Err(e) = &self {
             let location = std::panic::Location::caller();
 
+            let separator = if msg.is_none() { "" } else { ": " };
+            let msg = msg.unwrap_or_default();
+
             // We are using Anyhow's .context() and to show the inner error, too, we need the {:#}:
             let full = format!(
-                "{file}:{line}: {e:#}",
+                "{file}:{line}: {msg}{separator}{e:#}",
                 file = location.file(),
                 line = location.line(),
+                msg = msg,
+                separator = separator,
                 e = e
             );
             // We can't use the warn!() macro here as the file!() and line!() macros

src/message.rs

@@ -5,6 +5,7 @@ use std::path::{Path, PathBuf};
 
 use anyhow::{ensure, format_err, Context as _, Result};
 use deltachat_derive::{FromSql, ToSql};
+use rusqlite::types::ValueRef;
 use serde::{Deserialize, Serialize};
 
 use crate::chat::{self, Chat, ChatId};
@@ -28,8 +29,8 @@ use crate::sql;
 use crate::stock_str;
 use crate::summary::Summary;
 use crate::tools::{
-    buf_compress, buf_decompress, create_smeared_timestamp, get_filebytes, get_filemeta,
-    gm2local_offset, read_file, time, timestamp_to_str, truncate,
+    create_smeared_timestamp, get_filebytes, get_filemeta, gm2local_offset, read_file, time,
+    timestamp_to_str, truncate,
 };
 
 /// Message ID, including reserved IDs.
@@ -77,7 +78,7 @@ impl MsgId {
     pub async fn get_state(self, context: &Context) -> Result<MessageState> {
         let result = context
             .sql
-            .query_get_value("SELECT state FROM msgs WHERE id=?", (self,))
+            .query_get_value("SELECT state FROM msgs WHERE id=?", paramsv![self])
             .await?
             .unwrap_or_default();
         Ok(result)
@@ -106,7 +107,7 @@ SET
   param='' 
 WHERE id=?;
 "#,
-                (chat_id, self),
+                paramsv![chat_id, self],
             )
             .await?;
 
@@ -119,19 +120,22 @@ WHERE id=?;
         // sure they are not left while the message is deleted.
         context
             .sql
-            .execute("DELETE FROM smtp WHERE msg_id=?", (self,))
+            .execute("DELETE FROM smtp WHERE msg_id=?", paramsv![self])
             .await?;
         context
             .sql
-            .execute("DELETE FROM msgs_mdns WHERE msg_id=?;", (self,))
+            .execute("DELETE FROM msgs_mdns WHERE msg_id=?;", paramsv![self])
             .await?;
         context
             .sql
-            .execute("DELETE FROM msgs_status_updates WHERE msg_id=?;", (self,))
+            .execute(
+                "DELETE FROM msgs_status_updates WHERE msg_id=?;",
+                paramsv![self],
+            )
             .await?;
         context
             .sql
-            .execute("DELETE FROM msgs WHERE id=?;", (self,))
+            .execute("DELETE FROM msgs WHERE id=?;", paramsv![self])
             .await?;
         Ok(())
     }
@@ -140,7 +144,7 @@ WHERE id=?;
         update_msg_state(context, self, MessageState::OutDelivered).await?;
         let chat_id: ChatId = context
             .sql
-            .query_get_value("SELECT chat_id FROM msgs WHERE id=?", (self,))
+            .query_get_value("SELECT chat_id FROM msgs WHERE id=?", paramsv![self])
             .await?
             .unwrap_or_default();
         context.emit_event(EventType::MsgDelivered {
@@ -325,7 +329,7 @@ impl Message {
                     " FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id",
                     " WHERE m.id=?;"
                 ),
-                (id,),
+                paramsv![id],
                 |row| {
                     let text = match row.get_ref("txt")? {
                         rusqlite::types::ValueRef::Text(buf) => {
@@ -946,7 +950,7 @@ impl Message {
             .sql
             .execute(
                 "UPDATE msgs SET param=? WHERE id=?;",
-                (self.param.to_string(), self.id),
+                paramsv![self.param.to_string(), self.id],
             )
             .await?;
         Ok(())
@@ -957,7 +961,7 @@ impl Message {
             .sql
             .execute(
                 "UPDATE msgs SET subject=? WHERE id=?;",
-                (&self.subject, self.id),
+                paramsv![self.subject, self.id],
             )
             .await?;
         Ok(())
@@ -1091,7 +1095,7 @@ pub async fn get_msg_info(context: &Context, msg_id: MsgId) -> Result<String> {
     let msg = Message::load_from_db(context, msg_id).await?;
     let rawtxt: Option<String> = context
         .sql
-        .query_get_value("SELECT txt_raw FROM msgs WHERE id=?;", (msg_id,))
+        .query_get_value("SELECT txt_raw FROM msgs WHERE id=?;", paramsv![msg_id])
         .await?;
 
     let mut ret = String::new();
@@ -1141,7 +1145,7 @@ pub async fn get_msg_info(context: &Context, msg_id: MsgId) -> Result<String> {
         .sql
         .query_map(
             "SELECT contact_id, timestamp_sent FROM msgs_mdns WHERE msg_id=?;",
-            (msg_id,),
+            paramsv![msg_id],
             |row| {
                 let contact_id: ContactId = row.get(0)?;
                 let ts: i64 = row.get(1)?;
@@ -1222,7 +1226,7 @@ pub async fn get_msg_info(context: &Context, msg_id: MsgId) -> Result<String> {
             .sql
             .query_map(
                 "SELECT folder, uid FROM imap WHERE rfc724_mid=?",
-                (msg.rfc724_mid,),
+                paramsv![msg.rfc724_mid],
                 |row| {
                     let folder: String = row.get("folder")?;
                     let uid: u32 = row.get("uid")?;
@@ -1242,7 +1246,7 @@ pub async fn get_msg_info(context: &Context, msg_id: MsgId) -> Result<String> {
     }
     let hop_info: Option<String> = context
         .sql
-        .query_get_value("SELECT hop_info FROM msgs WHERE id=?;", (msg_id,))
+        .query_get_value("SELECT hop_info FROM msgs WHERE id=?;", paramsv![msg_id])
         .await?;
 
     ret += "\n\n";
@@ -1346,52 +1350,21 @@ pub(crate) fn guess_msgtype_from_suffix(path: &Path) -> Option<(Viewtype, &str)>
 /// e.g. because of save_mime_headers is not set
 /// or the message is not incoming.
 pub async fn get_mime_headers(context: &Context, msg_id: MsgId) -> Result<Vec<u8>> {
-    let (headers, compressed) = context
+    let headers = context
         .sql
         .query_row(
-            "SELECT mime_headers, mime_compressed FROM msgs WHERE id=?",
-            (msg_id,),
+            "SELECT mime_headers FROM msgs WHERE id=?;",
+            paramsv![msg_id],
             |row| {
-                let headers = sql::row_get_vec(row, 0)?;
-                let compressed: bool = row.get(1)?;
-                Ok((headers, compressed))
+                row.get(0).or_else(|err| match row.get_ref(0)? {
+                    ValueRef::Null => Ok(Vec::new()),
+                    ValueRef::Text(text) => Ok(text.to_vec()),
+                    ValueRef::Blob(blob) => Ok(blob.to_vec()),
+                    ValueRef::Integer(_) | ValueRef::Real(_) => Err(err),
+                })
             },
         )
         .await?;
-    if compressed {
-        return buf_decompress(&headers);
-    }
-
-    let headers2 = headers.clone();
-    let compressed = match tokio::task::block_in_place(move || buf_compress(&headers2)) {
-        Err(e) => {
-            warn!(context, "get_mime_headers: buf_compress() failed: {}", e);
-            return Ok(headers);
-        }
-        Ok(o) => o,
-    };
-    let update = |conn: &mut rusqlite::Connection| {
-        match conn.execute(
-            "\
-            UPDATE msgs SET mime_headers=?, mime_compressed=1 \
-            WHERE id=? AND mime_headers!='' AND mime_compressed=0",
-            (compressed, msg_id),
-        ) {
-            Ok(rows_updated) => ensure!(rows_updated <= 1),
-            Err(e) => {
-                warn!(context, "get_mime_headers: UPDATE failed: {}", e);
-                return Err(e.into());
-            }
-        }
-        Ok(())
-    };
-    if let Err(e) = context.sql.call_write(update).await {
-        warn!(
-            context,
-            "get_mime_headers: failed to update mime_headers: {}", e
-        );
-    }
-
     Ok(headers)
 }
 
@@ -1418,14 +1391,14 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
             .sql
             .execute(
                 "UPDATE imap SET target=? WHERE rfc724_mid=?",
-                (target, msg.rfc724_mid),
+                paramsv![target, msg.rfc724_mid],
             )
             .await?;
 
         let logging_xdc_id = context
             .debug_logging
             .read()
-            .expect("RwLock is poisoned")
+            .await
             .as_ref()
             .map(|dl| dl.msg_id);
 
@@ -1440,6 +1413,8 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
         context.emit_msgs_changed_without_ids();
 
         // Run housekeeping to delete unused blobs.
+        // We need to use set_raw_config() here since with set_config() it
+        // wouldn't compile ("recursion in an `async fn`")
         context.set_config(Config::LastHousekeeping, None).await?;
     }
 
@@ -1456,7 +1431,7 @@ async fn delete_poi_location(context: &Context, location_id: u32) -> Result<()>
         .sql
         .execute(
             "DELETE FROM locations WHERE independent = 1 AND id=?;",
-            (location_id as i32,),
+            paramsv![location_id as i32],
         )
         .await?;
     Ok(())
@@ -1468,12 +1443,6 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
         return Ok(());
     }
 
-    let old_last_msg_id = MsgId::new(context.get_config_u32(Config::LastMsgId).await?);
-    let last_msg_id = msg_ids.iter().fold(&old_last_msg_id, std::cmp::max);
-    context
-        .set_config_u32(Config::LastMsgId, last_msg_id.to_u32())
-        .await?;
-
     let msgs = context
         .sql
         .query_map(
@@ -1561,7 +1530,7 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                         .sql
                         .execute(
                             "INSERT INTO smtp_mdns (msg_id, from_id, rfc724_mid) VALUES(?, ?, ?)",
-                            (id, curr_from_id, curr_rfc724_mid),
+                            paramsv![id, curr_from_id, curr_rfc724_mid],
                         )
                         .await
                         .context("failed to insert into smtp_mdns")?;
@@ -1589,7 +1558,10 @@ pub(crate) async fn update_msg_state(
 ) -> Result<()> {
     context
         .sql
-        .execute("UPDATE msgs SET state=? WHERE id=?;", (state, msg_id))
+        .execute(
+            "UPDATE msgs SET state=? WHERE id=?;",
+            paramsv![state, msg_id],
+        )
         .await?;
     Ok(())
 }
@@ -1609,7 +1581,7 @@ pub(crate) async fn exists(context: &Context, msg_id: MsgId) -> Result<bool> {
 
     let chat_id: Option<ChatId> = context
         .sql
-        .query_get_value("SELECT chat_id FROM msgs WHERE id=?;", (msg_id,))
+        .query_get_value("SELECT chat_id FROM msgs WHERE id=?;", paramsv![msg_id])
         .await?;
 
     if let Some(chat_id) = chat_id {
@@ -1635,7 +1607,7 @@ pub(crate) async fn set_msg_failed(context: &Context, msg_id: MsgId, error: &str
             .sql
             .execute(
                 "UPDATE msgs SET state=?, error=? WHERE id=?;",
-                (msg.state, error, msg_id),
+                paramsv![msg.state, error, msg_id],
             )
             .await
         {
@@ -1680,7 +1652,7 @@ pub async fn handle_mdn(
                 " WHERE rfc724_mid=? AND from_id=1",
                 " ORDER BY m.id;"
             ),
-            (&rfc724_mid,),
+            paramsv![rfc724_mid],
             |row| {
                 Ok((
                     row.get::<_, MsgId>("msg_id")?,
@@ -1706,7 +1678,7 @@ pub async fn handle_mdn(
         .sql
         .exists(
             "SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=? AND contact_id=?;",
-            (msg_id, from_id),
+            paramsv![msg_id, from_id],
         )
         .await?
     {
@@ -1714,7 +1686,7 @@ pub async fn handle_mdn(
             .sql
             .execute(
                 "INSERT INTO msgs_mdns (msg_id, contact_id, timestamp_sent) VALUES (?, ?, ?);",
-                (msg_id, from_id, timestamp_sent),
+                paramsv![msg_id, from_id, timestamp_sent],
             )
             .await?;
     }
@@ -1754,7 +1726,7 @@ pub(crate) async fn handle_ndn(
                 " FROM msgs m LEFT JOIN chats c ON m.chat_id=c.id",
                 " WHERE rfc724_mid=? AND from_id=1",
             ),
-            (&failed.rfc724_mid,),
+            paramsv![failed.rfc724_mid],
             |row| {
                 Ok((
                     row.get::<_, MsgId>("msg_id")?,
@@ -1894,7 +1866,7 @@ pub async fn estimate_deletion_cnt(
                AND timestamp < ?
                AND chat_id != ?
                AND EXISTS (SELECT * FROM imap WHERE rfc724_mid=m.rfc724_mid);",
-                (DC_MSG_ID_LAST_SPECIAL, threshold_timestamp, self_chat_id),
+                paramsv![DC_MSG_ID_LAST_SPECIAL, threshold_timestamp, self_chat_id],
             )
             .await?
     } else {
@@ -1907,12 +1879,12 @@ pub async fn estimate_deletion_cnt(
                AND timestamp < ?
                AND chat_id != ?
                AND chat_id != ? AND hidden = 0;",
-                (
+                paramsv![
                     DC_MSG_ID_LAST_SPECIAL,
                     threshold_timestamp,
                     self_chat_id,
-                    DC_CHAT_ID_TRASH,
-                ),
+                    DC_CHAT_ID_TRASH
+                ],
             )
             .await?
     };
@@ -1933,7 +1905,7 @@ pub(crate) async fn rfc724_mid_exists(
         .sql
         .query_row_optional(
             "SELECT id FROM msgs WHERE rfc724_mid=?",
-            (rfc724_mid,),
+            paramsv![rfc724_mid],
             |row| {
                 let msg_id: MsgId = row.get(0)?;
 

src/mimefactory.rs

@@ -27,13 +27,16 @@ use crate::simplify::escape_message_footer_marks;
 use crate::stock_str;
 use crate::tools::IsNoneOrEmpty;
 use crate::tools::{
-    create_outgoing_rfc724_mid, create_smeared_timestamp, remove_subject_prefix, time,
+    create_outgoing_rfc724_mid, create_smeared_timestamp, get_filebytes, remove_subject_prefix,
+    time,
 };
 
 // attachments of 25 mb brutto should work on the majority of providers
 // (brutto examples: web.de=50, 1&1=40, t-online.de=32, gmail=25, posteo=50, yahoo=25, all-inkl=100).
+// as an upper limit, we double the size; the core won't send messages larger than this
 // to get the netto sizes, we subtract 1 mb header-overhead and the base64-overhead.
 pub const RECOMMENDED_FILE_SIZE: u64 = 24 * 1024 * 1024 / 4 * 3;
+const UPPER_LIMIT_FILE_SIZE: u64 = 49 * 1024 * 1024 / 4 * 3;
 
 #[derive(Debug, Clone)]
 pub enum Loaded {
@@ -166,7 +169,7 @@ impl<'a> MimeFactory<'a> {
                  FROM chats_contacts cc  \
                  LEFT JOIN contacts c ON cc.contact_id=c.id  \
                  WHERE cc.chat_id=? AND cc.contact_id>9;",
-                    (msg.chat_id,),
+                    paramsv![msg.chat_id],
                     |row| {
                         let authname: String = row.get(0)?;
                         let addr: String = row.get(1)?;
@@ -195,7 +198,7 @@ impl<'a> MimeFactory<'a> {
             .sql
             .query_row(
                 "SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?",
-                (msg.id,),
+                paramsv![msg.id],
                 |row| {
                     let in_reply_to: String = row.get(0)?;
                     let references: String = row.get(1)?;
@@ -945,6 +948,17 @@ impl<'a> MimeFactory<'a> {
                             "Secure-Join".to_string(),
                             "vg-member-added".to_string(),
                         ));
+                        // FIXME: Old clients require Secure-Join-Fingerprint header. Remove this
+                        // eventually.
+                        let fingerprint = Peerstate::from_addr(context, email_to_add)
+                            .await?
+                            .context("No peerstate found in db")?
+                            .public_key_fingerprint
+                            .context("No public key fingerprint in db for the member to add")?;
+                        headers.protected.push(Header::new(
+                            "Secure-Join-Fingerprint".into(),
+                            fingerprint.hex(),
+                        ));
                     }
                 }
                 SystemMessage::GroupNameChanged => {
@@ -1197,8 +1211,15 @@ impl<'a> MimeFactory<'a> {
 
         // add attachment part
         if self.msg.viewtype.has_file() {
-            let (file_part, _) = build_body_file(context, self.msg, "").await?;
-            parts.push(file_part);
+            if !is_file_size_okay(context, self.msg).await? {
+                bail!(
+                    "Message exceeds the recommended {} MB.",
+                    RECOMMENDED_FILE_SIZE / 1_000_000,
+                );
+            } else {
+                let (file_part, _) = build_body_file(context, self.msg, "").await?;
+                parts.push(file_part);
+            }
         }
 
         if let Some(meta_part) = meta_part {
@@ -1462,6 +1483,16 @@ fn recipients_contain_addr(recipients: &[(String, String)], addr: &str) -> bool
         .any(|(_, cur)| cur.to_lowercase() == addr_lc)
 }
 
+async fn is_file_size_okay(context: &Context, msg: &Message) -> Result<bool> {
+    match msg.param.get_path(Param::File, context)? {
+        Some(path) => {
+            let bytes = get_filebytes(context, &path).await?;
+            Ok(bytes <= UPPER_LIMIT_FILE_SIZE)
+        }
+        None => Ok(false),
+    }
+}
+
 fn render_rfc724_mid(rfc724_mid: &str) -> String {
     let rfc724_mid = rfc724_mid.trim().to_string();
 

src/mimeparser.rs

@@ -33,7 +33,7 @@ use crate::peerstate::Peerstate;
 use crate::simplify::{simplify, SimplifiedText};
 use crate::stock_str;
 use crate::sync::SyncItems;
-use crate::tools::{get_filemeta, parse_receive_headers, strip_rtlo_characters, truncate_by_lines};
+use crate::tools::{get_filemeta, parse_receive_headers, truncate_by_lines};
 use crate::{location, tools};
 
 /// A parsed MIME message.
@@ -90,9 +90,6 @@ pub(crate) struct MimeMessage {
     pub(crate) delivery_report: Option<DeliveryReport>,
 
     /// Standard USENET signature, if any.
-    ///
-    /// `None` means no text part was received, empty string means a text part without a footer is
-    /// received.
     pub(crate) footer: Option<String>,
 
     // if this flag is set, the parts/text/etc. are just close to the original mime-message;
@@ -1062,7 +1059,6 @@ impl MimeMessage {
                             }
                         };
 
-                        let is_plaintext = mime_type == mime::TEXT_PLAIN;
                         let mut dehtml_failed = false;
 
                         let SimplifiedText {
@@ -1143,9 +1139,7 @@ impl MimeMessage {
                             self.is_forwarded = true;
                         }
 
-                        if self.footer.is_none() && is_plaintext {
-                            self.footer = Some(footer.unwrap_or_default());
-                        }
+                        self.footer = footer;
                     }
                     _ => {}
                 }
@@ -1289,7 +1283,7 @@ impl MimeMessage {
         if !key.details.users.iter().any(|user| {
             user.id
                 .id()
-                .ends_with((String::from("<") + &peerstate.addr + ">").as_bytes())
+                .ends_with(&(String::from("<") + &peerstate.addr + ">"))
         }) {
             return Ok(false);
         }
@@ -1674,7 +1668,10 @@ impl MimeMessage {
         {
             context
                 .sql
-                .query_get_value("SELECT timestamp FROM msgs WHERE rfc724_mid=?", (field,))
+                .query_get_value(
+                    "SELECT timestamp FROM msgs WHERE rfc724_mid=?",
+                    paramsv![field],
+                )
                 .await?
         } else {
             None
@@ -1955,8 +1952,6 @@ fn get_attachment_filename(
         };
     }
 
-    let desired_filename = desired_filename.map(|filename| strip_rtlo_characters(&filename));
-
     Ok(desired_filename)
 }
 
@@ -2355,7 +2350,7 @@ mod tests {
             .sql
             .execute(
                 "INSERT INTO msgs (rfc724_mid, timestamp) VALUES(?,?)",
-                ("Gr.beZgAF2Nn0-.oyaJOpeuT70@example.org", timestamp),
+                paramsv!["Gr.beZgAF2Nn0-.oyaJOpeuT70@example.org", timestamp],
             )
             .await
             .expect("Failed to write to the database");

src/net.rs

@@ -78,7 +78,7 @@ async fn lookup_host_with_cache(
                  VALUES (?, ?, ?)
                  ON CONFLICT (hostname, address)
                  DO UPDATE SET timestamp=excluded.timestamp",
-                (hostname, ip_string, now),
+                paramsv![hostname, ip_string, now],
             )
             .await?;
     }
@@ -92,7 +92,7 @@ async fn lookup_host_with_cache(
                  WHERE hostname = ?
                  AND ? < timestamp + 30 * 24 * 3600
                  ORDER BY timestamp DESC",
-                (hostname, now),
+                paramsv![hostname, now],
                 |row| {
                     let address: String = row.get(0)?;
                     Ok(address)
@@ -160,7 +160,7 @@ pub(crate) async fn connect_tcp(
                         "UPDATE dns_cache
                          SET timestamp = ?
                          WHERE address = ?",
-                        (time(), resolved_addr.ip().to_string()),
+                        paramsv![time(), resolved_addr.ip().to_string()],
                     )
                     .await?;
                 break;

src/peerstate.rs

@@ -144,7 +144,7 @@ impl Peerstate {
                      verified_key, verified_key_fingerprint, verifier \
                      FROM acpeerstates \
                      WHERE addr=? COLLATE NOCASE LIMIT 1;";
-        Self::from_stmt(context, query, (addr,)).await
+        Self::from_stmt(context, query, paramsv![addr]).await
     }
 
     /// Loads peerstate corresponding to the given fingerprint from the database.
@@ -160,7 +160,7 @@ impl Peerstate {
                      OR gossip_key_fingerprint=? \
                      ORDER BY public_key_fingerprint=? DESC LIMIT 1;";
         let fp = fingerprint.hex();
-        Self::from_stmt(context, query, (&fp, &fp, &fp)).await
+        Self::from_stmt(context, query, paramsv![fp, fp, fp]).await
     }
 
     /// Loads peerstate by address or verified fingerprint.
@@ -180,7 +180,7 @@ impl Peerstate {
                      OR addr=? COLLATE NOCASE \
                      ORDER BY verified_key_fingerprint=? DESC, last_seen DESC LIMIT 1;";
         let fp = fingerprint.hex();
-        Self::from_stmt(context, query, (&fp, &addr, &fp)).await
+        Self::from_stmt(context, query, paramsv![fp, addr, fp]).await
     }
 
     async fn from_stmt(
@@ -471,7 +471,7 @@ impl Peerstate {
                   verified_key = excluded.verified_key,
                   verified_key_fingerprint = excluded.verified_key_fingerprint,
                   verifier = excluded.verifier",
-            (
+            paramsv![
                 self.last_seen,
                 self.last_seen_autocrypt,
                 self.prefer_encrypt as i64,
@@ -482,9 +482,9 @@ impl Peerstate {
                 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,
+                self.addr,
                 self.verifier.as_deref().unwrap_or(""),
-            ),
+            ],
         )
         .await?;
         Ok(())
@@ -524,7 +524,7 @@ impl Peerstate {
             .sql
             .query_get_value(
                 "SELECT id FROM contacts WHERE addr=? COLLATE NOCASE;",
-                (&self.addr,),
+                paramsv![self.addr],
             )
             .await?
             .with_context(|| format!("contact with peerstate.addr {:?} not found", &self.addr))?;
@@ -554,7 +554,7 @@ impl Peerstate {
                     .sql
                     .query_get_value(
                         "SELECT created_timestamp FROM chats WHERE id=?;",
-                        (chat_id,),
+                        paramsv![chat_id],
                     )
                     .await?
                     .unwrap_or(0)
@@ -851,7 +851,7 @@ mod tests {
         // can be loaded without errors.
         ctx.ctx
             .sql
-            .execute("INSERT INTO acpeerstates (addr) VALUES(?)", (addr,))
+            .execute("INSERT INTO acpeerstates (addr) VALUES(?)", paramsv![addr])
             .await
             .expect("Failed to write to the database");
 

src/pgp.rs

@@ -10,8 +10,7 @@ use pgp::composed::{
     Deserializable, KeyType as PgpKeyType, Message, SecretKeyParamsBuilder, SignedPublicKey,
     SignedPublicSubKey, SignedSecretKey, StandaloneSignature, SubkeyParamsBuilder,
 };
-use pgp::crypto::hash::HashAlgorithm;
-use pgp::crypto::sym::SymmetricKeyAlgorithm;
+use pgp::crypto::{HashAlgorithm, SymmetricKeyAlgorithm};
 use pgp::types::{
     CompressionAlgorithm, KeyTrait, Mpi, PublicKeyTrait, SecretKeyTrait, StringToKey,
 };
@@ -51,7 +50,7 @@ impl<'a> KeyTrait for SignedPublicKeyOrSubkey<'a> {
         }
     }
 
-    fn algorithm(&self) -> pgp::crypto::public_key::PublicKeyAlgorithm {
+    fn algorithm(&self) -> pgp::crypto::PublicKeyAlgorithm {
         match self {
             Self::Key(k) => k.algorithm(),
             Self::Subkey(k) => k.algorithm(),
@@ -298,7 +297,7 @@ pub fn pk_decrypt(
 
     let skeys: Vec<&SignedSecretKey> = private_keys_for_decryption.keys().iter().collect();
 
-    let (decryptor, _) = msg.decrypt(|| "".into(), &skeys[..])?;
+    let (decryptor, _) = msg.decrypt(|| "".into(), || "".into(), &skeys[..])?;
     let msgs = decryptor.collect::<pgp::errors::Result<Vec<_>>>()?;
 
     if let Some(msg) = msgs.into_iter().next() {

src/provider.rs

@@ -3,11 +3,12 @@
 mod data;
 
 use anyhow::Result;
+use chrono::{NaiveDateTime, NaiveTime};
 use trust_dns_resolver::{config, AsyncResolver, TokioAsyncResolver};
 
 use crate::config::Config;
 use crate::context::Context;
-use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS};
+use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS, PROVIDER_UPDATED};
 
 /// Provider status according to manual testing.
 #[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
@@ -257,12 +258,22 @@ pub fn get_provider_by_id(id: &str) -> Option<&'static Provider> {
     }
 }
 
+/// Returns update timestamp as a unix timestamp compatible for comparison with time() and database times.
+pub fn get_provider_update_timestamp() -> i64 {
+    NaiveDateTime::new(*PROVIDER_UPDATED, NaiveTime::from_hms_opt(0, 0, 0).unwrap())
+        .timestamp_millis()
+        / 1_000
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::indexing_slicing)]
 
+    use chrono::NaiveDate;
+
     use super::*;
     use crate::test_utils::TestContext;
+    use crate::tools::time;
 
     #[test]
     fn test_get_provider_by_domain_unexistant() {
@@ -325,6 +336,18 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_get_provider_update_timestamp() {
+        let timestamp_past = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2020, 9, 9).unwrap(),
+            NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
+        )
+        .timestamp_millis()
+            / 1_000;
+        assert!(get_provider_update_timestamp() <= time());
+        assert!(get_provider_update_timestamp() > timestamp_past);
+    }
+
     #[test]
     fn test_get_resolver() -> Result<()> {
         assert!(get_resolver().is_ok());

src/provider/data.rs

@@ -1945,5 +1945,5 @@ pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> =
     ])
 });
 
-pub static _PROVIDER_UPDATED: Lazy<chrono::NaiveDate> =
+pub static PROVIDER_UPDATED: Lazy<chrono::NaiveDate> =
     Lazy::new(|| chrono::NaiveDate::from_ymd_opt(2023, 2, 20).unwrap());

src/qr.rs

@@ -10,7 +10,7 @@ use percent_encoding::percent_decode_str;
 use serde::Deserialize;
 
 use self::dclogin_scheme::configure_from_login_qr;
-use crate::chat::{get_chat_id_by_grpid, ChatIdBlocked};
+use crate::chat::{self, get_chat_id_by_grpid, ChatIdBlocked};
 use crate::config::Config;
 use crate::constants::Blocked;
 use crate::contact::{
@@ -21,6 +21,7 @@ use crate::key::Fingerprint;
 use crate::message::Message;
 use crate::peerstate::Peerstate;
 use crate::socks::Socks5Config;
+use crate::tools::time;
 use crate::{token, EventType};
 
 const OPENPGP4FPR_SCHEME: &str = "OPENPGP4FPR:"; // yes: uppercase
@@ -434,9 +435,16 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Result<Qr> {
                 Contact::add_or_lookup(context, &name, peerstate_addr, Origin::UnhandledQrScan)
                     .await
                     .context("add_or_lookup")?;
-            ChatIdBlocked::get_for_contact(context, contact_id, Blocked::Request)
+            let chat = ChatIdBlocked::get_for_contact(context, contact_id, Blocked::Request)
                 .await
                 .context("Failed to create (new) chat for contact")?;
+            chat::add_info_msg(
+                context,
+                chat.id,
+                &format!("{} verified.", peerstate.addr),
+                time(),
+            )
+            .await?;
             Ok(Qr::FprOk { contact_id })
         } else {
             let contact_id = Contact::lookup_id_by_addr(context, &addr, Origin::Unknown)
@@ -500,7 +508,7 @@ fn decode_webrtc_instance(_context: &Context, qr: &str) -> Result<Qr> {
 fn decode_backup(qr: &str) -> Result<Qr> {
     let payload = qr
         .strip_prefix(DCBACKUP_SCHEME)
-        .ok_or_else(|| anyhow!("invalid DCBACKUP scheme"))?;
+        .ok_or(anyhow!("invalid DCBACKUP scheme"))?;
     let ticket: iroh::provider::Ticket = payload.parse().context("invalid DCBACKUP payload")?;
     Ok(Qr::Backup { ticket })
 }

src/reaction.rs

@@ -156,7 +156,7 @@ async fn set_msg_id_reaction(
                 "DELETE FROM reactions
                  WHERE msg_id = ?1
                  AND contact_id = ?2",
-                (msg_id, contact_id),
+                paramsv![msg_id, contact_id],
             )
             .await?;
     } else {
@@ -167,7 +167,7 @@ async fn set_msg_id_reaction(
                  VALUES (?1, ?2, ?3)
                  ON CONFLICT(msg_id, contact_id)
                  DO UPDATE SET reaction=excluded.reaction",
-                (msg_id, contact_id, reaction.as_str()),
+                paramsv![msg_id, contact_id, reaction.as_str()],
             )
             .await?;
     }
@@ -247,7 +247,7 @@ async fn get_self_reaction(context: &Context, msg_id: MsgId) -> Result<Reaction>
             "SELECT reaction
              FROM reactions
              WHERE msg_id=? AND contact_id=?",
-            (msg_id, ContactId::SELF),
+            paramsv![msg_id, ContactId::SELF],
         )
         .await?;
     Ok(reaction_str
@@ -262,7 +262,7 @@ pub async fn get_msg_reactions(context: &Context, msg_id: MsgId) -> Result<React
         .sql
         .query_map(
             "SELECT contact_id, reaction FROM reactions WHERE msg_id=?",
-            (msg_id,),
+            paramsv![msg_id],
             |row| {
                 let contact_id: ContactId = row.get(0)?;
                 let reaction: String = row.get(1)?;
@@ -287,14 +287,12 @@ pub async fn get_msg_reactions(context: &Context, msg_id: MsgId) -> Result<React
 mod tests {
     use super::*;
     use crate::chat::get_chat_msgs;
-    use crate::config::Config;
     use crate::constants::DC_CHAT_ID_TRASH;
     use crate::contact::{Contact, ContactAddress, Origin};
     use crate::download::DownloadState;
     use crate::message::MessageState;
     use crate::receive_imf::{receive_imf, receive_imf_inner};
     use crate::test_utils::TestContext;
-    use crate::test_utils::TestContextManager;
 
     #[test]
     fn test_parse_reaction() {
@@ -552,40 +550,4 @@ Content-Disposition: reaction\n\
 
         Ok(())
     }
-
-    /// Regression test for reaction resetting self-status.
-    ///
-    /// Reactions do not contain the status,
-    /// but should not result in self-status being reset on other devices.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_reaction_status_multidevice() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice1 = tcm.alice().await;
-        let alice2 = tcm.alice().await;
-
-        alice1
-            .set_config(Config::Selfstatus, Some("New status"))
-            .await?;
-
-        let alice2_msg = tcm.send_recv(&alice1, &alice2, "Hi!").await;
-        assert_eq!(
-            alice2.get_config(Config::Selfstatus).await?.as_deref(),
-            Some("New status")
-        );
-
-        // Alice reacts to own message from second device,
-        // first device receives rection.
-        {
-            send_reaction(&alice2, alice2_msg.id, "👍").await?;
-            let msg = alice2.pop_sent_msg().await;
-            alice1.recv_msg(&msg).await;
-        }
-
-        // Check that the status is still the same.
-        assert_eq!(
-            alice1.get_config(Config::Selfstatus).await?.as_deref(),
-            Some("New status")
-        );
-        Ok(())
-    }
 }

src/receive_imf.rs

@@ -37,9 +37,7 @@ 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::{
-    buf_compress, extract_grpid_from_rfc724_mid, smeared_time, strip_rtlo_characters,
-};
+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).
@@ -118,7 +116,7 @@ pub(crate) async fn receive_imf_inner(
                     .sql
                     .execute(
                         "INSERT INTO msgs(rfc724_mid, chat_id) VALUES (?,?)",
-                        (rfc724_mid, DC_CHAT_ID_TRASH),
+                        paramsv![rfc724_mid, DC_CHAT_ID_TRASH],
                     )
                     .await?;
                 msg_ids = vec![MsgId::new(u32::try_from(row_id)?)];
@@ -309,25 +307,28 @@ pub(crate) async fn receive_imf_inner(
         }
     }
 
+    // Always update the status, even if there is no footer, to allow removing the status.
+    //
+    // Ignore MDNs though, as they never contain the signature even if user has set it.
     // Ignore footers from mailinglists as they are often created or modified by the mailinglist software.
-    if let Some(footer) = &mime_parser.footer {
-        if !mime_parser.is_mailinglist_message()
-            && from_id != ContactId::UNDEFINED
-            && context
-                .update_contacts_timestamp(from_id, Param::StatusTimestamp, sent_timestamp)
-                .await?
+    if mime_parser.mdn_reports.is_empty()
+        && !mime_parser.is_mailinglist_message()
+        && is_partial_download.is_none()
+        && from_id != ContactId::UNDEFINED
+        && context
+            .update_contacts_timestamp(from_id, Param::StatusTimestamp, sent_timestamp)
+            .await?
+    {
+        if let Err(err) = contact::set_status(
+            context,
+            from_id,
+            mime_parser.footer.clone().unwrap_or_default(),
+            mime_parser.was_encrypted(),
+            mime_parser.has_chat_version(),
+        )
+        .await
         {
-            if let Err(err) = contact::set_status(
-                context,
-                from_id,
-                footer.to_string(),
-                mime_parser.was_encrypted(),
-                mime_parser.has_chat_version(),
-            )
-            .await
-            {
-                warn!(context, "Cannot update contact status: {err:#}.");
-            }
+            warn!(context, "Cannot update contact status: {err:#}.");
         }
     }
 
@@ -343,7 +344,7 @@ pub(crate) async fn receive_imf_inner(
                 .sql
                 .execute(
                     "UPDATE imap SET target=? WHERE rfc724_mid=?",
-                    (target, rfc724_mid),
+                    paramsv![target, rfc724_mid],
                 )
                 .await?;
         } else if !mime_parser.mdn_reports.is_empty() && mime_parser.has_chat_version() {
@@ -360,7 +361,6 @@ pub(crate) async fn receive_imf_inner(
             chat_id.emit_msg_event(context, *msg_id, incoming && fresh);
         }
     }
-    context.new_msgs_notify.notify_one();
 
     mime_parser
         .handle_reports(context, from_id, sent_timestamp, &mime_parser.parts)
@@ -551,18 +551,18 @@ async fn add_parts(
         // signals whether the current user is a bot
         let is_bot = context.get_config_bool(Config::Bot).await?;
 
-        let create_blocked = match test_normal_chat {
-            Some(ChatIdBlocked {
-                id: _,
-                blocked: Blocked::Request,
-            }) if is_bot => Blocked::Not,
-            Some(ChatIdBlocked { id: _, blocked }) => blocked,
-            None => Blocked::Request,
-        };
-
         if chat_id.is_none() {
             // try to create a group
 
+            let create_blocked = match test_normal_chat {
+                Some(ChatIdBlocked {
+                    id: _,
+                    blocked: Blocked::Not,
+                }) => Blocked::Not,
+                _ if is_bot => Blocked::Not,
+                _ => Blocked::Request,
+            };
+
             if let Some((new_chat_id, new_chat_id_blocked)) = create_or_lookup_group(
                 context,
                 mime_parser,
@@ -579,15 +579,13 @@ async fn add_parts(
             {
                 chat_id = Some(new_chat_id);
                 chat_id_blocked = new_chat_id_blocked;
-            }
-        }
 
-        // if the chat is somehow blocked but we want to create a non-blocked chat,
-        // unblock the chat
-        if chat_id_blocked != Blocked::Not && create_blocked != Blocked::Yes {
-            if let Some(chat_id) = chat_id {
-                chat_id.set_blocked(context, create_blocked).await?;
-                chat_id_blocked = create_blocked;
+                // if the chat is somehow blocked but we want to create a non-blocked chat,
+                // unblock the chat
+                if chat_id_blocked != Blocked::Not && create_blocked == Blocked::Not {
+                    new_chat_id.unblock(context).await?;
+                    chat_id_blocked = Blocked::Not;
+                }
             }
         }
 
@@ -693,8 +691,7 @@ async fn add_parts(
             } else if allow_creation {
                 if let Ok(chat) = ChatIdBlocked::get_for_contact(context, from_id, create_blocked)
                     .await
-                    .context("Failed to get (new) chat for contact")
-                    .log_err(context)
+                    .log_err(context, "Failed to get (new) chat for contact")
                 {
                     chat_id = Some(chat.id);
                     chat_id_blocked = chat.blocked;
@@ -846,8 +843,7 @@ async fn add_parts(
             // maybe an Autocrypt Setup Message
             if let Ok(chat) = ChatIdBlocked::get_for_contact(context, ContactId::SELF, Blocked::Not)
                 .await
-                .context("Failed to get (new) chat for contact")
-                .log_err(context)
+                .log_err(context, "Failed to get (new) chat for contact")
             {
                 chat_id = Some(chat.id);
                 chat_id_blocked = chat.blocked;
@@ -1067,19 +1063,18 @@ async fn add_parts(
     let mut save_mime_modified = mime_parser.is_mime_modified;
 
     let mime_headers = if save_mime_headers || save_mime_modified {
-        let headers = if mime_parser.was_encrypted() && !mime_parser.decoded_data.is_empty() {
+        if mime_parser.was_encrypted() && !mime_parser.decoded_data.is_empty() {
             mime_parser.decoded_data.clone()
         } else {
             imf_raw.to_vec()
-        };
-        tokio::task::block_in_place(move || buf_compress(&headers))?
+        }
     } else {
         Vec::new()
     };
 
     let mut created_db_entries = Vec::with_capacity(mime_parser.parts.len());
 
-    for part in &mut mime_parser.parts {
+    for part in &mime_parser.parts {
         if part.is_reaction {
             set_msg_reaction(
                 context,
@@ -1095,7 +1090,6 @@ async fn add_parts(
         if is_system_message != SystemMessage::Unknown {
             param.set_int(Param::Cmd, is_system_message as i32);
         }
-
         if let Some(replace_msg_id) = replace_msg_id {
             let placeholder = Message::load_from_db(context, replace_msg_id).await?;
             for key in [
@@ -1156,7 +1150,7 @@ INSERT INTO msgs
     from_id, to_id, timestamp, timestamp_sent, 
     timestamp_rcvd, type, state, msgrmsg, 
     txt, subject, txt_raw, param, 
-    bytes, mime_headers, mime_compressed, mime_in_reply_to,
+    bytes, mime_headers, mime_in_reply_to,
     mime_references, mime_modified, error, ephemeral_timer,
     ephemeral_timestamp, download_state, hop_info
   )
@@ -1165,7 +1159,7 @@ INSERT INTO msgs
     ?, ?, ?, ?,
     ?, ?, ?, ?,
     ?, ?, ?, ?,
-    ?, ?, ?, ?, 1,
+    ?, ?, ?, ?,
     ?, ?, ?, ?,
     ?, ?, ?, ?
   )
@@ -1174,8 +1168,7 @@ SET rfc724_mid=excluded.rfc724_mid, chat_id=excluded.chat_id,
     from_id=excluded.from_id, to_id=excluded.to_id, timestamp=excluded.timestamp, timestamp_sent=excluded.timestamp_sent,
     timestamp_rcvd=excluded.timestamp_rcvd, type=excluded.type, state=excluded.state, msgrmsg=excluded.msgrmsg,
     txt=excluded.txt, subject=excluded.subject, txt_raw=excluded.txt_raw, param=excluded.param,
-    bytes=excluded.bytes, mime_headers=excluded.mime_headers,
-    mime_compressed=excluded.mime_compressed, mime_in_reply_to=excluded.mime_in_reply_to,
+    bytes=excluded.bytes, mime_headers=excluded.mime_headers, mime_in_reply_to=excluded.mime_in_reply_to,
     mime_references=excluded.mime_references, mime_modified=excluded.mime_modified, error=excluded.error, ephemeral_timer=excluded.ephemeral_timer,
     ephemeral_timestamp=excluded.ephemeral_timestamp, download_state=excluded.download_state, hop_info=excluded.hop_info
 "#)?;
@@ -1365,7 +1358,7 @@ async fn calc_sort_timestamp(
             .sql
             .query_get_value(
                 "SELECT MAX(timestamp) FROM msgs WHERE chat_id=? AND state>?",
-                (chat_id, MessageState::InFresh),
+                paramsv![chat_id, MessageState::InFresh],
             )
             .await?;
 
@@ -1684,7 +1677,7 @@ async fn apply_group_changes(
                         .sql
                         .execute(
                             "UPDATE chats SET name=? WHERE id=?;",
-                            (strip_rtlo_characters(grpname), chat_id),
+                            paramsv![grpname.to_string(), chat_id],
                         )
                         .await?;
                     send_event_chat_modified = true;
@@ -1754,7 +1747,10 @@ async fn apply_group_changes(
                 // start from scratch.
                 context
                     .sql
-                    .execute("DELETE FROM chats_contacts WHERE chat_id=?;", (chat_id,))
+                    .execute(
+                        "DELETE FROM chats_contacts WHERE chat_id=?;",
+                        paramsv![chat_id],
+                    )
                     .await?;
 
                 members_to_add.push(ContactId::SELF);

src/receive_imf/tests.rs

@@ -367,13 +367,14 @@ async fn test_no_message_id_header() {
     )
     .await
     .unwrap();
+    dbg!(&received);
     assert!(received.is_none());
 
     assert!(!t
         .sql
         .exists(
             "SELECT COUNT(*) FROM msgs WHERE chat_id=?;",
-            (DC_CHAT_ID_TRASH,),
+            paramsv![DC_CHAT_ID_TRASH],
         )
         .await
         .unwrap());
@@ -3045,54 +3046,6 @@ async fn test_no_private_reply_to_blocked_account() -> Result<()> {
     Ok(())
 }
 
-/// Regression test for two bugs:
-///
-/// 1. If you blocked some spammer using DC, the 1:1 messages with that contact
-///    are not received, but they could easily bypass this restriction creating
-///    a new group with only you two as member.
-/// 2. A blocked group was sometimes not unblocked when when an unblocked
-///    contact sent a message into it.
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_blocked_contact_creates_group() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = tcm.alice().await;
-    let bob = tcm.bob().await;
-    let fiona = tcm.fiona().await;
-
-    let chat = alice.create_chat(&bob).await;
-    chat.id.block(&alice).await?;
-
-    let group_id = bob
-        .create_group_with_members(
-            ProtectionStatus::Unprotected,
-            "group name",
-            &[&alice, &fiona],
-        )
-        .await;
-
-    let sent = bob.send_text(group_id, "Heyho, I'm a spammer!").await;
-    let rcvd = alice.recv_msg(&sent).await;
-    // Alice blocked Bob, so she shouldn't get the message
-    assert_eq!(rcvd.chat_blocked, Blocked::Yes);
-
-    // Fiona didn't block Bob, though, so she gets the message
-    let rcvd = fiona.recv_msg(&sent).await;
-    assert_eq!(rcvd.chat_blocked, Blocked::Request);
-
-    // Fiona writes to the group
-    rcvd.chat_id.accept(&fiona).await?;
-    let sent = fiona.send_text(rcvd.chat_id, "Hello from Fiona").await;
-
-    // The group is unblocked now that Fiona sent a message to it
-    let rcvd = alice.recv_msg(&sent).await;
-    assert_eq!(rcvd.chat_blocked, Blocked::Request);
-    // In order not to lose context, Bob's message should also be shown in the group
-    let msgs = chat::get_chat_msgs(&alice, rcvd.chat_id).await?;
-    assert_eq!(msgs.len(), 2);
-
-    Ok(())
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_thunderbird_autocrypt() -> Result<()> {
     let t = TestContext::new_bob().await;

src/release.rs

@@ -1,10 +0,0 @@
-//! DC release info.
-
-use chrono::NaiveDate;
-use once_cell::sync::Lazy;
-
-const DATE_STR: &str = include_str!("../release-date.in");
-
-/// Last release date.
-pub static DATE: Lazy<NaiveDate> =
-    Lazy::new(|| NaiveDate::parse_from_str(DATE_STR, "%Y-%m-%d").unwrap());

src/scheduler.rs

@@ -1,8 +1,7 @@
 use std::iter::{self, once};
-use std::num::NonZeroUsize;
 use std::sync::atomic::Ordering;
 
-use anyhow::{bail, Context as _, Error, Result};
+use anyhow::{bail, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
 use futures::future::try_join_all;
 use futures_lite::FutureExt;
@@ -44,32 +43,24 @@ impl SchedulerState {
     /// Whether the scheduler is currently running.
     pub(crate) async fn is_running(&self) -> bool {
         let inner = self.inner.read().await;
-        matches!(*inner, InnerSchedulerState::Started(_))
+        inner.scheduler.is_some()
     }
 
     /// Starts the scheduler if it is not yet started.
     pub(crate) async fn start(&self, context: Context) {
         let mut inner = self.inner.write().await;
-        match *inner {
-            InnerSchedulerState::Started(_) => (),
-            InnerSchedulerState::Stopped => Self::do_start(inner, context).await,
-            InnerSchedulerState::Paused {
-                ref mut started, ..
-            } => *started = true,
+        inner.started = true;
+        if inner.scheduler.is_none() && !inner.paused {
+            Self::do_start(inner, context).await;
         }
     }
 
     /// Starts the scheduler if it is not yet started.
     async fn do_start(mut inner: RwLockWriteGuard<'_, InnerSchedulerState>, context: Context) {
         info!(context, "starting IO");
-
-        // Notify message processing loop
-        // to allow processing old messages after restart.
-        context.new_msgs_notify.notify_one();
-
         let ctx = context.clone();
         match Scheduler::start(context).await {
-            Ok(scheduler) => *inner = InnerSchedulerState::Started(scheduler),
+            Ok(scheduler) => inner.scheduler = Some(scheduler),
             Err(err) => error!(&ctx, "Failed to start IO: {:#}", err),
         }
     }
@@ -77,46 +68,23 @@ impl SchedulerState {
     /// Stops the scheduler if it is currently running.
     pub(crate) async fn stop(&self, context: &Context) {
         let mut inner = self.inner.write().await;
-        match *inner {
-            InnerSchedulerState::Started(_) => {
-                Self::do_stop(inner, context, InnerSchedulerState::Stopped).await
-            }
-            InnerSchedulerState::Stopped => (),
-            InnerSchedulerState::Paused {
-                ref mut started, ..
-            } => *started = false,
-        }
+        inner.started = false;
+        Self::do_stop(inner, context).await;
     }
 
     /// Stops the scheduler if it is currently running.
-    async fn do_stop(
-        mut inner: RwLockWriteGuard<'_, InnerSchedulerState>,
-        context: &Context,
-        new_state: InnerSchedulerState,
-    ) {
+    async fn do_stop(mut inner: RwLockWriteGuard<'_, InnerSchedulerState>, context: &Context) {
         // Sending an event wakes up event pollers (get_next_event)
         // so the caller of stop_io() can arrange for proper termination.
         // For this, the caller needs to instruct the event poller
         // to terminate on receiving the next event and then call stop_io()
         // which will emit the below event(s)
         info!(context, "stopping IO");
-
-        // Wake up message processing loop even if there are no messages
-        // to allow for clean shutdown.
-        context.new_msgs_notify.notify_one();
-
-        if let Some(debug_logging) = context
-            .debug_logging
-            .read()
-            .expect("RwLock is poisoned")
-            .as_ref()
-        {
+        if let Some(debug_logging) = context.debug_logging.read().await.as_ref() {
             debug_logging.loop_handle.abort();
         }
-        let prev_state = std::mem::replace(&mut *inner, new_state);
-        match prev_state {
-            InnerSchedulerState::Started(scheduler) => scheduler.stop(context).await,
-            InnerSchedulerState::Stopped | InnerSchedulerState::Paused { .. } => (),
+        if let Some(scheduler) = inner.scheduler.take() {
+            scheduler.stop(context).await;
         }
     }
 
@@ -128,63 +96,22 @@ impl SchedulerState {
     /// If in the meantime [`SchedulerState::start`] or [`SchedulerState::stop`] is called
     /// resume will do the right thing and restore the scheduler to the state requested by
     /// the last call.
-    pub(crate) async fn pause<'a>(&'_ self, context: Context) -> Result<IoPausedGuard> {
+    pub(crate) async fn pause<'a>(&'_ self, context: Context) -> IoPausedGuard {
         {
             let mut inner = self.inner.write().await;
-            match *inner {
-                InnerSchedulerState::Started(_) => {
-                    let new_state = InnerSchedulerState::Paused {
-                        started: true,
-                        pause_guards_count: NonZeroUsize::new(1).unwrap(),
-                    };
-                    Self::do_stop(inner, &context, new_state).await;
-                }
-                InnerSchedulerState::Stopped => {
-                    *inner = InnerSchedulerState::Paused {
-                        started: false,
-                        pause_guards_count: NonZeroUsize::new(1).unwrap(),
-                    };
-                }
-                InnerSchedulerState::Paused {
-                    ref mut pause_guards_count,
-                    ..
-                } => {
-                    *pause_guards_count = pause_guards_count
-                        .checked_add(1)
-                        .ok_or_else(|| Error::msg("Too many pause guards active"))?
-                }
-            }
+            inner.paused = true;
+            Self::do_stop(inner, &context).await;
         }
-
         let (tx, rx) = oneshot::channel();
         tokio::spawn(async move {
             rx.await.ok();
             let mut inner = context.scheduler.inner.write().await;
-            match *inner {
-                InnerSchedulerState::Started(_) => {
-                    warn!(&context, "IoPausedGuard resume: started instead of paused");
-                }
-                InnerSchedulerState::Stopped => {
-                    warn!(&context, "IoPausedGuard resume: stopped instead of paused");
-                }
-                InnerSchedulerState::Paused {
-                    ref started,
-                    ref mut pause_guards_count,
-                } => {
-                    if *pause_guards_count == NonZeroUsize::new(1).unwrap() {
-                        match *started {
-                            true => SchedulerState::do_start(inner, context.clone()).await,
-                            false => *inner = InnerSchedulerState::Stopped,
-                        }
-                    } else {
-                        let new_count = pause_guards_count.get() - 1;
-                        // SAFETY: Value was >=2 before due to if condition
-                        *pause_guards_count = NonZeroUsize::new(new_count).unwrap();
-                    }
-                }
+            inner.paused = false;
+            if inner.started && inner.scheduler.is_none() {
+                SchedulerState::do_start(inner, context.clone()).await;
             }
         });
-        Ok(IoPausedGuard { sender: Some(tx) })
+        IoPausedGuard { sender: Some(tx) }
     }
 
     /// Restarts the scheduler, only if it is running.
@@ -199,8 +126,8 @@ impl SchedulerState {
     /// Indicate that the network likely has come back.
     pub(crate) async fn maybe_network(&self) {
         let inner = self.inner.read().await;
-        let (inbox, oboxes) = match *inner {
-            InnerSchedulerState::Started(ref scheduler) => {
+        let (inbox, oboxes) = match inner.scheduler {
+            Some(ref scheduler) => {
                 scheduler.maybe_network();
                 let inbox = scheduler.inbox.conn_state.state.connectivity.clone();
                 let oboxes = scheduler
@@ -210,7 +137,7 @@ impl SchedulerState {
                     .collect::<Vec<_>>();
                 (inbox, oboxes)
             }
-            _ => return,
+            None => return,
         };
         drop(inner);
         connectivity::idle_interrupted(inbox, oboxes).await;
@@ -219,15 +146,15 @@ impl SchedulerState {
     /// Indicate that the network likely is lost.
     pub(crate) async fn maybe_network_lost(&self, context: &Context) {
         let inner = self.inner.read().await;
-        let stores = match *inner {
-            InnerSchedulerState::Started(ref scheduler) => {
+        let stores = match inner.scheduler {
+            Some(ref scheduler) => {
                 scheduler.maybe_network_lost();
                 scheduler
                     .boxes()
                     .map(|b| b.conn_state.state.connectivity.clone())
                     .collect()
             }
-            _ => return,
+            None => return,
         };
         drop(inner);
         connectivity::maybe_network_lost(context, stores).await;
@@ -235,49 +162,45 @@ impl SchedulerState {
 
     pub(crate) async fn interrupt_inbox(&self, info: InterruptInfo) {
         let inner = self.inner.read().await;
-        if let InnerSchedulerState::Started(ref scheduler) = *inner {
+        if let Some(ref scheduler) = inner.scheduler {
             scheduler.interrupt_inbox(info);
         }
     }
 
     pub(crate) async fn interrupt_smtp(&self, info: InterruptInfo) {
         let inner = self.inner.read().await;
-        if let InnerSchedulerState::Started(ref scheduler) = *inner {
+        if let Some(ref scheduler) = inner.scheduler {
             scheduler.interrupt_smtp(info);
         }
     }
 
     pub(crate) async fn interrupt_ephemeral_task(&self) {
         let inner = self.inner.read().await;
-        if let InnerSchedulerState::Started(ref scheduler) = *inner {
+        if let Some(ref scheduler) = inner.scheduler {
             scheduler.interrupt_ephemeral_task();
         }
     }
 
     pub(crate) async fn interrupt_location(&self) {
         let inner = self.inner.read().await;
-        if let InnerSchedulerState::Started(ref scheduler) = *inner {
+        if let Some(ref scheduler) = inner.scheduler {
             scheduler.interrupt_location();
         }
     }
 
     pub(crate) async fn interrupt_recently_seen(&self, contact_id: ContactId, timestamp: i64) {
         let inner = self.inner.read().await;
-        if let InnerSchedulerState::Started(ref scheduler) = *inner {
+        if let Some(ref scheduler) = inner.scheduler {
             scheduler.interrupt_recently_seen(contact_id, timestamp);
         }
     }
 }
 
 #[derive(Debug, Default)]
-enum InnerSchedulerState {
-    Started(Scheduler),
-    #[default]
-    Stopped,
-    Paused {
-        started: bool,
-        pause_guards_count: NonZeroUsize,
-    },
+struct InnerSchedulerState {
+    scheduler: Option<Scheduler>,
+    started: bool,
+    paused: bool,
 }
 
 /// Guard to make sure the IO Scheduler is resumed.
@@ -323,11 +246,7 @@ pub(crate) struct Scheduler {
     recently_seen_loop: RecentlySeenLoop,
 }
 
-async fn inbox_loop(
-    ctx: Context,
-    started: oneshot::Sender<()>,
-    inbox_handlers: ImapConnectionHandlers,
-) {
+async fn inbox_loop(ctx: Context, started: Sender<()>, inbox_handlers: ImapConnectionHandlers) {
     use futures::future::FutureExt;
 
     info!(ctx, "starting inbox loop");
@@ -339,8 +258,8 @@ async fn inbox_loop(
     let ctx1 = ctx.clone();
     let fut = async move {
         let ctx = ctx1;
-        if let Err(()) = started.send(()) {
-            warn!(ctx, "inbox loop, missing started receiver");
+        if let Err(err) = started.send(()).await {
+            warn!(ctx, "inbox loop, missing started receiver: {}", err);
             return;
         };
 
@@ -382,7 +301,7 @@ async fn inbox_loop(
                             let next_housekeeping_time =
                                 last_housekeeping_time.saturating_add(60 * 60 * 24);
                             if next_housekeeping_time <= time() {
-                                sql::housekeeping(&ctx).await.log_err(&ctx).ok();
+                                sql::housekeeping(&ctx).await.ok_or_log(&ctx);
                             }
                         }
                         Err(err) => {
@@ -491,8 +410,7 @@ async fn fetch_idle(
                 .store_seen_flags_on_imap(ctx)
                 .await
                 .context("store_seen_flags_on_imap")
-                .log_err(ctx)
-                .ok();
+                .ok_or_log(ctx);
         } else {
             warn!(ctx, "No session even though we just prepared it");
         }
@@ -516,8 +434,7 @@ async fn fetch_idle(
     delete_expired_imap_messages(ctx)
         .await
         .context("delete_expired_imap_messages")
-        .log_err(ctx)
-        .ok();
+        .ok_or_log(ctx);
 
     // Scan additional folders only after finishing fetching the watched folder.
     //
@@ -557,8 +474,7 @@ async fn fetch_idle(
         .sync_seen_flags(ctx, &watch_folder)
         .await
         .context("sync_seen_flags")
-        .log_err(ctx)
-        .ok();
+        .ok_or_log(ctx);
 
     connection.connectivity.set_connected(ctx).await;
 
@@ -604,7 +520,7 @@ async fn fetch_idle(
 
 async fn simple_imap_loop(
     ctx: Context,
-    started: oneshot::Sender<()>,
+    started: Sender<()>,
     inbox_handlers: ImapConnectionHandlers,
     folder_meaning: FolderMeaning,
 ) {
@@ -620,8 +536,8 @@ async fn simple_imap_loop(
 
     let fut = async move {
         let ctx = ctx1;
-        if let Err(()) = started.send(()) {
-            warn!(&ctx, "simple imap loop, missing started receiver");
+        if let Err(err) = started.send(()).await {
+            warn!(&ctx, "simple imap loop, missing started receiver: {}", err);
             return;
         }
 
@@ -639,11 +555,7 @@ async fn simple_imap_loop(
         .await;
 }
 
-async fn smtp_loop(
-    ctx: Context,
-    started: oneshot::Sender<()>,
-    smtp_handlers: SmtpConnectionHandlers,
-) {
+async fn smtp_loop(ctx: Context, started: Sender<()>, smtp_handlers: SmtpConnectionHandlers) {
     use futures::future::FutureExt;
 
     info!(ctx, "starting smtp loop");
@@ -656,8 +568,8 @@ async fn smtp_loop(
     let ctx1 = ctx.clone();
     let fut = async move {
         let ctx = ctx1;
-        if let Err(()) = started.send(()) {
-            warn!(&ctx, "smtp loop, missing started receiver");
+        if let Err(err) = started.send(()).await {
+            warn!(&ctx, "smtp loop, missing started receiver: {}", err);
             return;
         }
 
@@ -729,7 +641,7 @@ impl Scheduler {
     pub async fn start(ctx: Context) -> Result<Self> {
         let (smtp, smtp_handlers) = SmtpConnectionState::new();
 
-        let (smtp_start_send, smtp_start_recv) = oneshot::channel();
+        let (smtp_start_send, smtp_start_recv) = channel::bounded(1);
         let (ephemeral_interrupt_send, ephemeral_interrupt_recv) = channel::bounded(1);
         let (location_interrupt_send, location_interrupt_recv) = channel::bounded(1);
 
@@ -737,7 +649,7 @@ impl Scheduler {
         let mut start_recvs = Vec::new();
 
         let (conn_state, inbox_handlers) = ImapConnectionState::new(&ctx).await?;
-        let (inbox_start_send, inbox_start_recv) = oneshot::channel();
+        let (inbox_start_send, inbox_start_recv) = channel::bounded(1);
         let handle = {
             let ctx = ctx.clone();
             task::spawn(inbox_loop(ctx, inbox_start_send, inbox_handlers))
@@ -758,7 +670,7 @@ impl Scheduler {
         ] {
             if should_watch? {
                 let (conn_state, handlers) = ImapConnectionState::new(&ctx).await?;
-                let (start_send, start_recv) = oneshot::channel();
+                let (start_send, start_recv) = channel::bounded(1);
                 let ctx = ctx.clone();
                 let handle = task::spawn(simple_imap_loop(ctx, start_send, handlers, meaning));
                 oboxes.push(SchedBox {
@@ -805,7 +717,7 @@ impl Scheduler {
         };
 
         // wait for all loops to be started
-        if let Err(err) = try_join_all(start_recvs).await {
+        if let Err(err) = try_join_all(start_recvs.iter().map(|r| r.recv())).await {
             bail!("failed to start scheduler: {}", err);
         }
 
@@ -858,22 +770,20 @@ impl Scheduler {
     pub(crate) async fn stop(self, context: &Context) {
         // Send stop signals to tasks so they can shutdown cleanly.
         for b in self.boxes() {
-            b.conn_state.stop().await.log_err(context).ok();
+            b.conn_state.stop().await.ok_or_log(context);
         }
-        self.smtp.stop().await.log_err(context).ok();
+        self.smtp.stop().await.ok_or_log(context);
 
         // Actually shutdown tasks.
         let timeout_duration = std::time::Duration::from_secs(30);
         for b in once(self.inbox).chain(self.oboxes.into_iter()) {
             tokio::time::timeout(timeout_duration, b.handle)
                 .await
-                .log_err(context)
-                .ok();
+                .ok_or_log(context);
         }
         tokio::time::timeout(timeout_duration, self.smtp_handle)
             .await
-            .log_err(context)
-            .ok();
+            .ok_or_log(context);
         self.ephemeral_handle.abort();
         self.location_handle.abort();
         self.recently_seen_loop.abort();

src/scheduler/connectivity.rs

@@ -14,8 +14,6 @@ use crate::tools::time;
 use crate::{context::Context, log::LogExt};
 use crate::{stock_str, tools};
 
-use super::InnerSchedulerState;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumProperty, PartialOrd, Ord)]
 pub enum Connectivity {
     NotConnected = 1000,
@@ -228,12 +226,12 @@ impl Context {
     /// If the connectivity changes, a DC_EVENT_CONNECTIVITY_CHANGED will be emitted.
     pub async fn get_connectivity(&self) -> Connectivity {
         let lock = self.scheduler.inner.read().await;
-        let stores: Vec<_> = match *lock {
-            InnerSchedulerState::Started(ref sched) => sched
+        let stores: Vec<_> = match lock.scheduler {
+            Some(ref sched) => sched
                 .boxes()
                 .map(|b| b.conn_state.state.connectivity.clone())
                 .collect(),
-            _ => return Connectivity::NotConnected,
+            None => return Connectivity::NotConnected,
         };
         drop(lock);
 
@@ -311,15 +309,15 @@ impl Context {
         // =============================================================================================
 
         let lock = self.scheduler.inner.read().await;
-        let (folders_states, smtp) = match *lock {
-            InnerSchedulerState::Started(ref sched) => (
+        let (folders_states, smtp) = match lock.scheduler {
+            Some(ref sched) => (
                 sched
                     .boxes()
                     .map(|b| (b.meaning, b.conn_state.state.connectivity.clone()))
                     .collect::<Vec<_>>(),
                 sched.smtp.state.connectivity.clone(),
             ),
-            _ => {
+            None => {
                 return Err(anyhow!("Not started"));
             }
         };
@@ -339,7 +337,7 @@ impl Context {
             let mut folder_added = false;
 
             if let Some(config) = folder.to_config().filter(|c| watched_folders.contains(c)) {
-                let f = self.get_config(config).await.log_err(self).ok().flatten();
+                let f = self.get_config(config).await.ok_or_log(self).flatten();
 
                 if let Some(foldername) = f {
                     let detailed = &state.get_detailed().await;
@@ -398,72 +396,64 @@ impl Context {
         if let Some(quota) = &*quota {
             match &quota.recent {
                 Ok(quota) => {
-                    if !quota.is_empty() {
-                        for (root_name, resources) in quota {
-                            use async_imap::types::QuotaResourceName::*;
-                            for resource in resources {
-                                ret += "<li>";
+                    let roots_cnt = quota.len();
+                    for (root_name, resources) in quota {
+                        use async_imap::types::QuotaResourceName::*;
+                        for resource in resources {
+                            ret += "<li>";
 
-                                // root name is empty eg. for gmail and redundant eg. for riseup.
-                                // therefore, use it only if there are really several roots.
-                                if quota.len() > 1 && !root_name.is_empty() {
-                                    ret += &format!(
-                                        "<b>{}:</b> ",
-                                        &*escaper::encode_minimal(root_name)
-                                    );
-                                } else {
-                                    info!(
-                                        self,
-                                        "connectivity: root name hidden: \"{}\"", root_name
-                                    );
-                                }
-
-                                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(),
-                                )
-                                .await;
-                                ret += &match &resource.name {
-                                    Atom(resource_name) => {
-                                        format!(
-                                            "<b>{}:</b> {}",
-                                            &*escaper::encode_minimal(resource_name),
-                                            part_of_total_used
-                                        )
-                                    }
-                                    Message => {
-                                        format!("<b>{part_of_total_used}:</b> {messages}")
-                                    }
-                                    Storage => {
-                                        // do not use a special title needed for "Storage":
-                                        // - it is usually shown directly under the "Storage" headline
-                                        // - by the units "1 MB of 10 MB used" there is some difference to eg. "Messages: 1 of 10 used"
-                                        // - 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 = &format_size(resource.usage * 1024, BINARY);
-                                        let limit = &format_size(resource.limit * 1024, BINARY);
-                                        stock_str::part_of_total_used(self, usage, limit).await
-                                    }
-                                };
-
-                                let percent = resource.get_usage_percentage();
-                                let color = if percent >= QUOTA_ERROR_THRESHOLD_PERCENTAGE {
-                                    "red"
-                                } else if percent >= QUOTA_WARN_THRESHOLD_PERCENTAGE {
-                                    "yellow"
-                                } else {
-                                    "green"
-                                };
-                                ret += &format!("<div class=\"bar\"><div class=\"progress {color}\" style=\"width: {percent}%\">{percent}%</div></div>");
-
-                                ret += "</li>";
+                            // root name is empty eg. for gmail and redundant eg. for riseup.
+                            // therefore, use it only if there are really several roots.
+                            if roots_cnt > 1 && !root_name.is_empty() {
+                                ret +=
+                                    &format!("<b>{}:</b> ", &*escaper::encode_minimal(root_name));
+                            } else {
+                                info!(self, "connectivity: root name hidden: \"{}\"", root_name);
                             }
+
+                            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(),
+                            )
+                            .await;
+                            ret += &match &resource.name {
+                                Atom(resource_name) => {
+                                    format!(
+                                        "<b>{}:</b> {}",
+                                        &*escaper::encode_minimal(resource_name),
+                                        part_of_total_used
+                                    )
+                                }
+                                Message => {
+                                    format!("<b>{part_of_total_used}:</b> {messages}")
+                                }
+                                Storage => {
+                                    // do not use a special title needed for "Storage":
+                                    // - it is usually shown directly under the "Storage" headline
+                                    // - by the units "1 MB of 10 MB used" there is some difference to eg. "Messages: 1 of 10 used"
+                                    // - 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 = &format_size(resource.usage * 1024, BINARY);
+                                    let limit = &format_size(resource.limit * 1024, BINARY);
+                                    stock_str::part_of_total_used(self, usage, limit).await
+                                }
+                            };
+
+                            let percent = resource.get_usage_percentage();
+                            let color = if percent >= QUOTA_ERROR_THRESHOLD_PERCENTAGE {
+                                "red"
+                            } else if percent >= QUOTA_WARN_THRESHOLD_PERCENTAGE {
+                                "yellow"
+                            } else {
+                                "green"
+                            };
+                            ret += &format!("<div class=\"bar\"><div class=\"progress {color}\" style=\"width: {percent}%\">{percent}%</div></div>");
+
+                            ret += "</li>";
                         }
-                    } else {
-                        ret += format!("<li>Warning: {domain} claims to support quota but gives no information</li>").as_str();
                     }
                 }
                 Err(e) => {
@@ -490,14 +480,14 @@ impl Context {
     /// Returns true if all background work is done.
     pub async fn all_work_done(&self) -> bool {
         let lock = self.scheduler.inner.read().await;
-        let stores: Vec<_> = match *lock {
-            InnerSchedulerState::Started(ref sched) => sched
+        let stores: Vec<_> = match lock.scheduler {
+            Some(ref sched) => sched
                 .boxes()
                 .map(|b| &b.conn_state.state)
                 .chain(once(&sched.smtp.state))
                 .map(|state| state.connectivity.clone())
                 .collect(),
-            _ => return false,
+            None => return false,
         };
         drop(lock);
 

src/securejoin.rs

@@ -9,7 +9,7 @@ use crate::aheader::EncryptPreference;
 use crate::chat::{self, Chat, ChatId, ChatIdBlocked};
 use crate::config::Config;
 use crate::constants::Blocked;
-use crate::contact::{Contact, ContactId, Origin};
+use crate::contact::{Contact, ContactId, Origin, VerifiedStatus};
 use crate::context::Context;
 use crate::e2ee::ensure_secret_key_exists;
 use crate::events::EventType;
@@ -465,9 +465,14 @@ pub(crate) async fn handle_securejoin_handshake(
                     info_chat_id(context, contact_id).await?,
                 )
                 .await?;
-                send_alice_handshake_msg(context, contact_id, "vc-contact-confirm", None)
-                    .await
-                    .context("failed sending vc-contact-confirm message")?;
+                send_alice_handshake_msg(
+                    context,
+                    contact_id,
+                    "vc-contact-confirm",
+                    Some(fingerprint),
+                )
+                .await
+                .context("failed sending vc-contact-confirm message")?;
 
                 inviter_progress!(context, contact_id, 1000);
             }
@@ -489,8 +494,33 @@ pub(crate) async fn handle_securejoin_handshake(
             }
         }
         "vg-member-added-received" | "vc-contact-confirm-received" => {
-            // The peer isn't updated yet and still sends these messages.
-            Ok(HandshakeMessage::Ignore)
+            /*==========================================================
+            ====              Alice - the inviter side              ====
+            ====  Step 8 in "Out-of-band verified groups" protocol  ====
+            ==========================================================*/
+
+            if let Ok(contact) = Contact::get_by_id(context, contact_id).await {
+                if contact.is_verified(context).await? == VerifiedStatus::Unverified {
+                    warn!(context, "{} invalid.", step);
+                    return Ok(HandshakeMessage::Ignore);
+                }
+                if join_vg {
+                    let field_grpid = mime_message
+                        .get_header(HeaderDef::SecureJoinGroup)
+                        .map(|s| s.as_str())
+                        .unwrap_or_else(|| "");
+                    if let Err(err) = chat::get_chat_id_by_grpid(context, field_grpid).await {
+                        warn!(context, "Failed to lookup chat_id from grpid: {}", err);
+                        return Err(
+                            err.context(format!("Chat for group {} not found", &field_grpid))
+                        );
+                    }
+                }
+                Ok(HandshakeMessage::Ignore) // "Done" deletes the message and breaks multi-device
+            } else {
+                warn!(context, "{} invalid.", step);
+                Ok(HandshakeMessage::Ignore)
+            }
         }
         _ => {
             warn!(context, "invalid step: {}", step);
@@ -510,6 +540,12 @@ pub(crate) async fn handle_securejoin_handshake(
 ///   The inviting device has marked a peer as verified on vg-request-with-auth/vc-request-with-auth
 ///   before sending vg-member-added/vc-contact-confirm - so, if we observe vg-member-added/vc-contact-confirm,
 ///   we can mark the peer as verified as well.
+///
+/// - if we see the self-sent-message vg-member-added-received
+///   we know that we're an joiner-observer.
+///   the joining device has marked the peer as verified on vg-member-added/vc-contact-confirm
+///   before sending vg-member-added-received - so, if we observe vg-member-added-received,
+///   we can mark the peer as verified as well.
 pub(crate) async fn observe_securejoin_on_other_device(
     context: &Context,
     mime_message: &MimeMessage,
@@ -527,7 +563,9 @@ pub(crate) async fn observe_securejoin_on_other_device(
         "vg-request-with-auth"
         | "vc-request-with-auth"
         | "vg-member-added"
-        | "vc-contact-confirm" => {
+        | "vc-contact-confirm"
+        | "vg-member-added-received"
+        | "vc-contact-confirm-received" => {
             if !encrypted_and_signed(
                 context,
                 mime_message,
@@ -593,6 +631,32 @@ pub(crate) async fn observe_securejoin_on_other_device(
                 }
                 peerstate.prefer_encrypt = EncryptPreference::Mutual;
                 peerstate.save_to_db(&context.sql).await.unwrap_or_default();
+            } else if let Some(fingerprint) =
+                mime_message.get_header(HeaderDef::SecureJoinFingerprint)
+            {
+                // FIXME: Old versions of DC send this header instead of gossips. Remove this
+                // eventually.
+                let fingerprint = fingerprint.parse()?;
+                if mark_peer_as_verified(
+                    context,
+                    fingerprint,
+                    Contact::load_from_db(context, contact_id)
+                        .await?
+                        .get_addr()
+                        .to_owned(),
+                )
+                .await
+                .is_err()
+                {
+                    could_not_establish_secure_connection(
+                        context,
+                        contact_id,
+                        info_chat_id(context, contact_id).await?,
+                        format!("Fingerprint mismatch on observing {step}.").as_ref(),
+                    )
+                    .await?;
+                    return Ok(HandshakeMessage::Ignore);
+                }
             } else {
                 could_not_establish_secure_connection(
                     context,
@@ -896,7 +960,7 @@ mod tests {
             VerifiedStatus::Unverified
         );
 
-        // Step 7: Bob receives vc-contact-confirm
+        // Step 7: Bob receives vc-contact-confirm, sends vc-contact-confirm-received
         bob.recv_msg(&sent).await;
         assert_eq!(
             contact_alice.is_verified(&bob.ctx).await.unwrap(),
@@ -921,6 +985,15 @@ mod tests {
             let text = msg.get_text().unwrap();
             assert!(text.contains("alice@example.org verified"));
         }
+
+        // Check Bob sent the final message
+        let sent = bob.pop_sent_msg().await;
+        let msg = alice.parse_msg(&sent).await;
+        assert!(msg.was_encrypted());
+        assert_eq!(
+            msg.get_header(HeaderDef::SecureJoin).unwrap(),
+            "vc-contact-confirm-received"
+        );
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -1038,12 +1111,20 @@ mod tests {
             VerifiedStatus::Unverified
         );
 
-        // Step 7: Bob receives vc-contact-confirm
+        // Step 7: Bob receives vc-contact-confirm, sends vc-contact-confirm-received
         bob.recv_msg(&sent).await;
         assert_eq!(
             contact_alice.is_verified(&bob.ctx).await?,
             VerifiedStatus::BidirectVerified
         );
+
+        let sent = bob.pop_sent_msg().await;
+        let msg = alice.parse_msg(&sent).await;
+        assert!(msg.was_encrypted());
+        assert_eq!(
+            msg.get_header(HeaderDef::SecureJoin).unwrap(),
+            "vc-contact-confirm-received"
+        );
         Ok(())
     }
 
@@ -1227,7 +1308,7 @@ mod tests {
             VerifiedStatus::Unverified
         );
 
-        // Step 7: Bob receives vg-member-added
+        // Step 7: Bob receives vg-member-added, sends vg-member-added-received
         bob.recv_msg(&sent).await;
         {
             // Bob has Alice verified, message shows up in the group chat.
@@ -1274,6 +1355,14 @@ mod tests {
             }
         }
 
+        let sent = bob.pop_sent_msg().await;
+        let msg = alice.parse_msg(&sent).await;
+        assert!(msg.was_encrypted());
+        assert_eq!(
+            msg.get_header(HeaderDef::SecureJoin).unwrap(),
+            "vg-member-added-received"
+        );
+
         let bob_chat = Chat::load_from_db(&bob.ctx, bob_chatid).await?;
         assert!(bob_chat.is_protected());
         assert!(bob_chat.typ == Chattype::Group);

src/securejoin/bobstate.rs

@@ -135,21 +135,21 @@ impl BobState {
                 // rows that we will delete.  So start with a dummy UPDATE.
                 transaction.execute(
                     r#"UPDATE bobstate SET next_step=?;"#,
-                    (SecureJoinStep::Terminated,),
+                    params![SecureJoinStep::Terminated],
                 )?;
                 let mut stmt = transaction.prepare("SELECT id FROM bobstate;")?;
                 let mut aborted = Vec::new();
-                for id in stmt.query_map((), |row| row.get::<_, i64>(0))? {
+                for id in stmt.query_map(params![], |row| row.get::<_, i64>(0))? {
                     let id = id?;
                     let state = BobState::from_db_id(transaction, id)?;
                     aborted.push(state);
                 }
 
                 // Finally delete everything and insert new row.
-                transaction.execute("DELETE FROM bobstate;", ())?;
+                transaction.execute("DELETE FROM bobstate;", params![])?;
                 transaction.execute(
                     "INSERT INTO bobstate (invite, next_step, chat_id) VALUES (?, ?, ?);",
-                    (invite, next, chat_id),
+                    params![invite, next, chat_id],
                 )?;
                 let id = transaction.last_insert_rowid();
                 Ok((id, aborted))
@@ -180,7 +180,7 @@ impl BobState {
     fn from_db_id(connection: &Connection, id: i64) -> rusqlite::Result<Self> {
         connection.query_row(
             "SELECT invite, next_step, chat_id FROM bobstate WHERE id=?;",
-            (id,),
+            params![id],
             |row| {
                 let s = BobState {
                     id,
@@ -217,12 +217,12 @@ impl BobState {
             SecureJoinStep::AuthRequired | SecureJoinStep::ContactConfirm => {
                 sql.execute(
                     "UPDATE bobstate SET next_step=? WHERE id=?;",
-                    (next, self.id),
+                    paramsv![next, self.id],
                 )
                 .await?;
             }
             SecureJoinStep::Terminated | SecureJoinStep::Completed => {
-                sql.execute("DELETE FROM bobstate WHERE id=?;", (self.id,))
+                sql.execute("DELETE FROM bobstate WHERE id=?;", paramsv!(self.id))
                     .await?;
             }
         }
@@ -386,6 +386,17 @@ impl BobState {
             }
         }
 
+        self.send_handshake_message(context, BobHandshakeMsg::ContactConfirmReceived)
+            .await
+            .map_err(|_| {
+                warn!(
+                    context,
+                    "Failed to send vc-contact-confirm-received/vg-member-added-received"
+                );
+            })
+            // This is not an error affecting the protocol outcome.
+            .ok();
+
         self.update_next(&context.sql, SecureJoinStep::Completed)
             .await?;
         Ok(Some(BobHandshakeStage::Completed))
@@ -431,6 +442,9 @@ async fn send_handshake_message(
             msg.param.set(Param::Arg2, invite.authcode());
             msg.param.set_int(Param::GuaranteeE2ee, 1);
         }
+        BobHandshakeMsg::ContactConfirmReceived => {
+            msg.param.set_int(Param::GuaranteeE2ee, 1);
+        }
     };
 
     // Sends our own fingerprint in the Secure-Join-Fingerprint header.
@@ -452,6 +466,8 @@ enum BobHandshakeMsg {
     Request,
     /// vc-request-with-auth or vg-request-with-auth
     RequestWithAuth,
+    /// vc-contact-confirm-received or vg-member-added-received
+    ContactConfirmReceived,
 }
 
 impl BobHandshakeMsg {
@@ -479,6 +495,10 @@ impl BobHandshakeMsg {
                 QrInvite::Contact { .. } => "vc-request-with-auth",
                 QrInvite::Group { .. } => "vg-request-with-auth",
             },
+            Self::ContactConfirmReceived => match invite {
+                QrInvite::Contact { .. } => "vc-contact-confirm-received",
+                QrInvite::Group { .. } => "vg-member-added-received",
+            },
         }
     }
 }

src/smtp.rs

@@ -520,7 +520,10 @@ pub(crate) async fn send_msg_to_smtp(
     // database.
     context
         .sql
-        .execute("UPDATE smtp SET retries=retries+1 WHERE id=?", (rowid,))
+        .execute(
+            "UPDATE smtp SET retries=retries+1 WHERE id=?",
+            paramsv![rowid],
+        )
         .await
         .context("failed to update retries count")?;
 
@@ -528,7 +531,7 @@ pub(crate) async fn send_msg_to_smtp(
         .sql
         .query_row(
             "SELECT mime, recipients, msg_id, retries FROM smtp WHERE id=?",
-            (rowid,),
+            paramsv![rowid],
             |row| {
                 let mime: String = row.get(0)?;
                 let recipients: String = row.get(1)?;
@@ -542,14 +545,14 @@ pub(crate) async fn send_msg_to_smtp(
         message::set_msg_failed(context, msg_id, "Number of retries exceeded the limit.").await;
         context
             .sql
-            .execute("DELETE FROM smtp WHERE id=?", (rowid,))
+            .execute("DELETE FROM smtp WHERE id=?", paramsv![rowid])
             .await
             .context("failed to remove message with exceeded retry limit from smtp table")?;
         bail!("Number of retries exceeded the limit");
     }
     info!(
         context,
-        "Try number {} to send message {} over SMTP", retries, msg_id
+        "Try number {retries} to send message {msg_id} (entry {rowid}) over SMTP"
     );
 
     let recipients_list = recipients
@@ -573,8 +576,13 @@ pub(crate) async fn send_msg_to_smtp(
     {
         info!(
             context,
-            "Sending of message {} was cancelled by the user.", msg_id
+            "Sending of message {msg_id} (entry {rowid}) was cancelled by the user."
         );
+        context
+            .sql
+            .execute("DELETE FROM smtp WHERE id=?", (rowid,))
+            .await
+            .context("failed to remove cancelled message from smtp table")?;
         return Ok(());
     }
 
@@ -585,7 +593,7 @@ pub(crate) async fn send_msg_to_smtp(
         SendResult::Success | SendResult::Failure(_) => {
             context
                 .sql
-                .execute("DELETE FROM smtp WHERE id=?", (rowid,))
+                .execute("DELETE FROM smtp WHERE id=?", paramsv![rowid])
                 .await?;
         }
     };
@@ -634,7 +642,7 @@ pub(crate) async fn send_smtp_messages(context: &Context, connection: &mut Smtp)
         .sql
         .query_map(
             "SELECT id FROM smtp ORDER BY id ASC",
-            (),
+            paramsv![],
             |row| {
                 let rowid: i64 = row.get(0)?;
                 Ok(rowid)
@@ -646,6 +654,8 @@ pub(crate) async fn send_smtp_messages(context: &Context, connection: &mut Smtp)
             },
         )
         .await?;
+
+    info!(context, "Selected rows from SMTP queue: {rowids:?}.");
     for rowid in rowids {
         send_msg_to_smtp(context, connection, rowid)
             .await
@@ -688,7 +698,7 @@ async fn send_mdn_msg_id(
             "SELECT msg_id, rfc724_mid
              FROM smtp_mdns
              WHERE from_id=? AND msg_id!=?",
-            (contact_id, msg_id),
+            paramsv![contact_id, msg_id],
             |row| {
                 let msg_id: MsgId = row.get(0)?;
                 let rfc724_mid: String = row.get(1)?;
@@ -715,7 +725,7 @@ async fn send_mdn_msg_id(
             info!(context, "Successfully sent MDN for {}", msg_id);
             context
                 .sql
-                .execute("DELETE FROM smtp_mdns WHERE msg_id = ?", (msg_id,))
+                .execute("DELETE FROM smtp_mdns WHERE msg_id = ?", paramsv![msg_id])
                 .await?;
             if !additional_msg_ids.is_empty() {
                 let q = format!(
@@ -776,7 +786,7 @@ async fn send_mdn(context: &Context, smtp: &mut Smtp) -> Result<bool> {
         .sql
         .execute(
             "UPDATE smtp_mdns SET retries=retries+1 WHERE msg_id=?",
-            (msg_id,),
+            paramsv![msg_id],
         )
         .await
         .context("failed to update MDN retries count")?;
@@ -786,7 +796,7 @@ async fn send_mdn(context: &Context, smtp: &mut Smtp) -> Result<bool> {
         // database, do not try to send this MDN again.
         context
             .sql
-            .execute("DELETE FROM smtp_mdns WHERE msg_id = ?", (msg_id,))
+            .execute("DELETE FROM smtp_mdns WHERE msg_id = ?", paramsv![msg_id])
             .await?;
         Err(err)
     } else {

src/smtp/send.rs

@@ -64,9 +64,11 @@ impl Smtp {
             if let Some(ref mut transport) = self.transport {
                 transport.send(mail).await.map_err(Error::SmtpSend)?;
 
-                context.emit_event(EventType::SmtpMessageSent(format!(
-                    "Message len={message_len_bytes} was smtp-sent to {recipients_display}"
-                )));
+                let info_msg = format!(
+                    "Message len={message_len_bytes} was SMTP-sent to {recipients_display}"
+                );
+                info!(context, "{info_msg}.");
+                context.emit_event(EventType::SmtpMessageSent(info_msg));
                 self.last_success = Some(std::time::SystemTime::now());
             } else {
                 warn!(

src/sql.rs

@@ -5,7 +5,7 @@ use std::convert::TryFrom;
 use std::path::{Path, PathBuf};
 
 use anyhow::{bail, Context as _, Result};
-use rusqlite::{self, config::DbConfig, types::ValueRef, Connection, OpenFlags, Row};
+use rusqlite::{self, config::DbConfig, Connection, OpenFlags};
 use tokio::sync::{Mutex, MutexGuard, RwLock};
 
 use crate::blob::BlobObject;
@@ -23,28 +23,27 @@ use crate::peerstate::{deduplicate_peerstates, Peerstate};
 use crate::stock_str;
 use crate::tools::{delete_file, time};
 
-/// Extension to [`rusqlite::ToSql`] trait
-/// which also includes [`Send`] and [`Sync`].
-pub trait ToSql: rusqlite::ToSql + Send + Sync {}
-
-impl<T: rusqlite::ToSql + Send + Sync> ToSql for T {}
-
-/// Constructs a slice of trait object references `&dyn ToSql`.
-///
-/// One of the uses is passing more than 16 parameters
-/// to a query, because [`rusqlite::Params`] is only implemented
-/// for tuples of up to 16 elements.
+#[allow(missing_docs)]
 #[macro_export]
-macro_rules! params_slice {
-    ($($param:expr),+) => {
-        [$(&$param as &dyn $crate::sql::ToSql),+]
+macro_rules! paramsv {
+    () => {
+        rusqlite::params_from_iter(Vec::<&dyn $crate::ToSql>::new())
+    };
+    ($($param:expr),+ $(,)?) => {
+        rusqlite::params_from_iter(vec![$(&$param as &dyn $crate::ToSql),+])
     };
 }
 
-pub(crate) fn params_iter(
-    iter: &[impl crate::sql::ToSql],
-) -> impl Iterator<Item = &dyn crate::sql::ToSql> {
-    iter.iter().map(|item| item as &dyn crate::sql::ToSql)
+#[allow(missing_docs)]
+#[macro_export]
+macro_rules! params_iterv {
+    ($($param:expr),+ $(,)?) => {
+        vec![$(&$param as &dyn $crate::ToSql),+]
+    };
+}
+
+pub(crate) fn params_iter(iter: &[impl crate::ToSql]) -> impl Iterator<Item = &dyn crate::ToSql> {
+    iter.iter().map(|item| item as &dyn crate::ToSql)
 }
 
 mod migrations;
@@ -58,7 +57,7 @@ pub struct Sql {
     /// Database file path
     pub(crate) dbfile: PathBuf,
 
-    /// Write transactions mutex.
+    /// Write transaction mutex.
     ///
     /// See [`Self::write_lock`].
     write_mtx: Mutex<()>,
@@ -140,8 +139,11 @@ impl Sql {
         let res = self
             .call_write(move |conn| {
                 // Check that backup passphrase is correct before resetting our database.
-                conn.execute("ATTACH DATABASE ? AS backup KEY ?", (path_str, passphrase))
-                    .context("failed to attach backup database")?;
+                conn.execute(
+                    "ATTACH DATABASE ? AS backup KEY ?",
+                    paramsv![path_str, passphrase],
+                )
+                .context("failed to attach backup database")?;
                 if let Err(err) = conn
                     .query_row("SELECT count(*) FROM sqlite_master", [], |_row| Ok(()))
                     .context("backup passphrase is not correct")
@@ -554,21 +556,27 @@ impl Sql {
         let mut lock = self.config_cache.write().await;
         if let Some(value) = value {
             let exists = self
-                .exists("SELECT COUNT(*) FROM config WHERE keyname=?;", (key,))
+                .exists(
+                    "SELECT COUNT(*) FROM config WHERE keyname=?;",
+                    paramsv![key],
+                )
                 .await?;
 
             if exists {
-                self.execute("UPDATE config SET value=? WHERE keyname=?;", (value, key))
-                    .await?;
+                self.execute(
+                    "UPDATE config SET value=? WHERE keyname=?;",
+                    paramsv![value, key],
+                )
+                .await?;
             } else {
                 self.execute(
                     "INSERT INTO config (keyname, value) VALUES (?, ?);",
-                    (key, value),
+                    paramsv![key, value],
                 )
                 .await?;
             }
         } else {
-            self.execute("DELETE FROM config WHERE keyname=?;", (key,))
+            self.execute("DELETE FROM config WHERE keyname=?;", paramsv![key])
                 .await?;
         }
         lock.insert(key.to_string(), value.map(|s| s.to_string()));
@@ -589,7 +597,7 @@ impl Sql {
 
         let mut lock = self.config_cache.write().await;
         let value = self
-            .query_get_value("SELECT value FROM config WHERE keyname=?;", (key,))
+            .query_get_value("SELECT value FROM config WHERE keyname=?;", paramsv![key])
             .await
             .context(format!("failed to fetch raw config: {key}"))?;
         lock.insert(key.to_string(), value.clone());
@@ -688,15 +696,6 @@ fn new_connection(path: &Path, passphrase: &str) -> Result<Connection> {
 
 /// Cleanup the account to restore some storage and optimize the database.
 pub async fn housekeeping(context: &Context) -> Result<()> {
-    // Setting `Config::LastHousekeeping` at the beginning avoids endless loops when things do not
-    // work out for whatever reason or are interrupted by the OS.
-    if let Err(e) = context
-        .set_config(Config::LastHousekeeping, Some(&time().to_string()))
-        .await
-    {
-        warn!(context, "Can't set config: {e:#}.");
-    }
-
     if let Err(err) = remove_unused_files(context).await {
         warn!(
             context,
@@ -744,6 +743,13 @@ pub async fn housekeeping(context: &Context) -> Result<()> {
         }
     }
 
+    if let Err(e) = context
+        .set_config(Config::LastHousekeeping, Some(&time().to_string()))
+        .await
+    {
+        warn!(context, "Can't set config: {e:#}.");
+    }
+
     context
         .sql
         .execute(
@@ -751,24 +757,12 @@ pub async fn housekeeping(context: &Context) -> Result<()> {
             (),
         )
         .await
-        .context("failed to remove old MDNs")
-        .log_err(context)
-        .ok();
+        .ok_or_log_msg(context, "failed to remove old MDNs");
 
     info!(context, "Housekeeping done.");
     Ok(())
 }
 
-/// Get the value of a column `idx` of the `row` as `Vec<u8>`.
-pub fn row_get_vec(row: &Row, idx: usize) -> rusqlite::Result<Vec<u8>> {
-    row.get(idx).or_else(|err| match row.get_ref(idx)? {
-        ValueRef::Null => Ok(Vec::new()),
-        ValueRef::Text(text) => Ok(text.to_vec()),
-        ValueRef::Blob(blob) => Ok(blob.to_vec()),
-        ValueRef::Integer(_) | ValueRef::Real(_) => Err(err),
-    })
-}
-
 /// Enumerates used files in the blobdir and removes unused ones.
 pub async fn remove_unused_files(context: &Context) -> Result<()> {
     let mut files_in_use = HashSet::new();
@@ -901,14 +895,12 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
                 }
             }
             Err(err) => {
-                if !p.ends_with(BLOBS_BACKUP_NAME) {
-                    warn!(
-                        context,
-                        "Housekeeping: Cannot read dir {}: {:#}.",
-                        p.display(),
-                        err
-                    );
-                }
+                warn!(
+                    context,
+                    "Housekeeping: Cannot read dir {}: {:#}.",
+                    p.display(),
+                    err
+                );
             }
         }
     }
@@ -972,7 +964,7 @@ async fn prune_tombstones(sql: &Sql) -> Result<()> {
          AND NOT EXISTS (
          SELECT * FROM imap WHERE msgs.rfc724_mid=rfc724_mid AND target!=''
          )",
-        (DC_CHAT_ID_TRASH,),
+        paramsv![DC_CHAT_ID_TRASH],
     )
     .await?;
     Ok(())
@@ -1155,12 +1147,12 @@ mod tests {
         sql.open(&t, "".to_string()).await?;
         sql.execute(
             "INSERT INTO config (keyname, value) VALUES (?, ?);",
-            ("foo", "bar"),
+            paramsv!("foo", "bar"),
         )
         .await?;
 
         let value: Option<String> = sql
-            .query_get_value("SELECT value FROM config WHERE keyname=?;", ("foo",))
+            .query_get_value("SELECT value FROM config WHERE keyname=?;", paramsv!("foo"))
             .await?;
         assert_eq!(value.unwrap(), "bar");
 

src/sql/migrations.rs

@@ -30,7 +30,7 @@ pub async fn run(context: &Context, sql: &Sql) -> Result<(bool, bool, bool, bool
             // set raw config inside the transaction
             transaction.execute(
                 "INSERT INTO config (keyname, value) VALUES (?, ?);",
-                (VERSION_CFG, format!("{dbversion_before_update}")),
+                paramsv![VERSION_CFG, format!("{dbversion_before_update}")],
             )?;
             Ok(())
         })
@@ -704,13 +704,6 @@ CREATE INDEX smtp_messageid ON imap(rfc724_mid);
         // Reverted above, as it requires to load the whole DB in memory.
         sql.set_db_version(99).await?;
     }
-    if dbversion < 100 {
-        sql.execute_migration(
-            "ALTER TABLE msgs ADD COLUMN mime_compressed INTEGER NOT NULL DEFAULT 0",
-            100,
-        )
-        .await?;
-    }
 
     let new_version = sql
         .get_raw_config_int(VERSION_CFG)
@@ -742,18 +735,14 @@ impl Sql {
         Ok(())
     }
 
-    // Sets db `version` in the `transaction`.
-    fn set_db_version_trans(transaction: &mut rusqlite::Transaction, version: i32) -> Result<()> {
-        transaction.execute(
-            "UPDATE config SET value=? WHERE keyname=?;",
-            (format!("{version}"), VERSION_CFG),
-        )?;
-        Ok(())
-    }
-
-    async fn execute_migration(&self, query: &str, version: i32) -> Result<()> {
+    async fn execute_migration(&self, query: &'static str, version: i32) -> Result<()> {
         self.transaction(move |transaction| {
-            Self::set_db_version_trans(transaction, version)?;
+            // set raw config inside the transaction
+            transaction.execute(
+                "UPDATE config SET value=? WHERE keyname=?;",
+                paramsv![format!("{version}"), VERSION_CFG],
+            )?;
+
             transaction.execute_batch(query)?;
 
             Ok(())

src/sync.rs

@@ -65,7 +65,10 @@ impl Context {
         let item = SyncItem { timestamp, data };
         let item = serde_json::to_string(&item)?;
         self.sql
-            .execute("INSERT INTO multi_device_sync (item) VALUES(?);", (item,))
+            .execute(
+                "INSERT INTO multi_device_sync (item) VALUES(?);",
+                paramsv![item],
+            )
             .await?;
 
         Ok(())

src/test_utils.rs

@@ -18,10 +18,7 @@ use tokio::runtime::Handle;
 use tokio::sync::RwLock;
 use tokio::task;
 
-use crate::chat::{
-    self, add_to_chat_contacts_table, create_group_chat, Chat, ChatId, MessageListOptions,
-    ProtectionStatus,
-};
+use crate::chat::{self, Chat, ChatId, MessageListOptions};
 use crate::chatlist::Chatlist;
 use crate::config::Config;
 use crate::constants::Chattype;
@@ -106,17 +103,9 @@ impl TestContextManager {
     /// - Let the other TestContext receive it and accept the chat
     /// - Assert that the message arrived
     pub async fn send_recv_accept(&self, from: &TestContext, to: &TestContext, msg: &str) {
-        let received_msg = self.send_recv(from, to, msg).await;
-        received_msg.chat_id.accept(to).await.unwrap();
-    }
-
-    /// - Let one TestContext send a message
-    /// - Let the other TestContext receive it
-    /// - Assert that the message arrived
-    pub async fn send_recv(&self, from: &TestContext, to: &TestContext, msg: &str) -> Message {
         let received_msg = self.try_send_recv(from, to, msg).await;
         assert_eq!(received_msg.text.as_ref().unwrap(), msg);
-        received_msg
+        received_msg.chat_id.accept(to).await.unwrap();
     }
 
     /// - Let one TestContext send a message
@@ -436,7 +425,7 @@ impl TestContext {
         };
         self.ctx
             .sql
-            .execute("DELETE FROM smtp WHERE id=?;", (rowid,))
+            .execute("DELETE FROM smtp WHERE id=?;", paramsv![rowid])
             .await
             .expect("failed to remove job");
         update_msg_state(&self.ctx, msg_id, MessageState::OutDelivered)
@@ -713,25 +702,6 @@ impl TestContext {
             );
         }
     }
-
-    pub async fn create_group_with_members(
-        &self,
-        protect: ProtectionStatus,
-        chat_name: &str,
-        members: &[&TestContext],
-    ) -> ChatId {
-        let chat_id = create_group_chat(self, protect, chat_name).await.unwrap();
-        let mut to_add = vec![];
-        for member in members {
-            let contact = self.add_or_lookup_contact(member).await;
-            to_add.push(contact.id);
-        }
-        add_to_chat_contacts_table(self, chat_id, &to_add)
-            .await
-            .unwrap();
-
-        chat_id
-    }
 }
 
 impl Deref for TestContext {

src/token.rs

@@ -35,7 +35,7 @@ pub async fn save(
             .sql
             .execute(
                 "INSERT INTO tokens (namespc, foreign_id, token, timestamp) VALUES (?, ?, ?, ?);",
-                (namespace, foreign_id, token, time()),
+                paramsv![namespace, foreign_id, token, time()],
             )
             .await?,
         None => {
@@ -43,7 +43,7 @@ pub async fn save(
                 .sql
                 .execute(
                     "INSERT INTO tokens (namespc, token, timestamp) VALUES (?, ?, ?);",
-                    (namespace, token, time()),
+                    paramsv![namespace, token, time()],
                 )
                 .await?
         }
@@ -71,7 +71,7 @@ pub async fn lookup(
                 .sql
                 .query_get_value(
                     "SELECT token FROM tokens WHERE namespc=? AND foreign_id=? ORDER BY timestamp DESC LIMIT 1;",
-                    (namespace, chat_id),
+                    paramsv![namespace, chat_id],
                 )
                 .await?
         }
@@ -81,7 +81,7 @@ pub async fn lookup(
                 .sql
                 .query_get_value(
                     "SELECT token FROM tokens WHERE namespc=? AND foreign_id=0 ORDER BY timestamp DESC LIMIT 1;",
-                    (namespace,),
+                    paramsv![namespace],
                 )
                 .await?
         }
@@ -108,7 +108,7 @@ pub async fn exists(context: &Context, namespace: Namespace, token: &str) -> boo
         .sql
         .exists(
             "SELECT COUNT(*) FROM tokens WHERE namespc=? AND token=?;",
-            (namespace, token),
+            paramsv![namespace, token],
         )
         .await
         .unwrap_or_default()
@@ -119,7 +119,7 @@ pub async fn delete(context: &Context, namespace: Namespace, token: &str) -> Res
         .sql
         .execute(
             "DELETE FROM tokens WHERE namespc=? AND token=?;",
-            (namespace, token),
+            paramsv![namespace, token],
         )
         .await?;
     Ok(())

src/tools.rs

@@ -5,15 +5,14 @@
 
 use std::borrow::Cow;
 use std::fmt;
-use std::io::{Cursor, Write};
-use std::mem;
+use std::io::Cursor;
 use std::path::{Path, PathBuf};
 use std::str::from_utf8;
 use std::time::{Duration, SystemTime};
 
 use anyhow::{bail, Context as _, Result};
 use base64::Engine as _;
-use chrono::{Local, NaiveDateTime, NaiveTime, TimeZone};
+use chrono::{Local, TimeZone};
 use futures::{StreamExt, TryStreamExt};
 use mailparse::dateparse;
 use mailparse::headers::Headers;
@@ -26,6 +25,7 @@ use crate::constants::{DC_ELLIPSIS, DC_OUTDATED_WARNING_DAYS};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::message::{Message, Viewtype};
+use crate::provider::get_provider_update_timestamp;
 use crate::stock_str;
 
 /// Shortens a string to a specified length and adds "[...]" to the
@@ -162,23 +162,12 @@ pub(crate) fn create_smeared_timestamps(context: &Context, count: usize) -> i64
     context.smeared_timestamp.create_n(now, count as i64)
 }
 
-/// Returns the last release timestamp as a unix timestamp compatible for comparison with time() and
-/// database times.
-pub fn get_release_timestamp() -> i64 {
-    NaiveDateTime::new(
-        *crate::release::DATE,
-        NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
-    )
-    .timestamp_millis()
-        / 1_000
-}
-
 // if the system time is not plausible, once a day, add a device message.
 // for testing we're using time() as that is also used for message timestamps.
 // moreover, add a warning if the app is outdated.
 pub(crate) async fn maybe_add_time_based_warnings(context: &Context) {
-    if !maybe_warn_on_bad_time(context, time(), get_release_timestamp()).await {
-        maybe_warn_on_outdated(context, time(), get_release_timestamp()).await;
+    if !maybe_warn_on_bad_time(context, time(), get_provider_update_timestamp()).await {
+        maybe_warn_on_outdated(context, time(), get_provider_update_timestamp()).await;
     }
 }
 
@@ -560,11 +549,9 @@ impl rusqlite::types::ToSql for EmailAddress {
     }
 }
 
-/// Sanitizes user input
-/// - strip newlines
-/// - strip malicious bidi characters
+/// Makes sure that a user input that is not supposed to contain newlines does not contain newlines.
 pub(crate) fn improve_single_line_input(input: &str) -> String {
-    strip_rtlo_characters(input.replace(['\n', '\r'], " ").trim())
+    input.replace(['\n', '\r'], " ").trim().to_string()
 }
 
 pub(crate) trait IsNoneOrEmpty<T> {
@@ -667,49 +654,6 @@ pub(crate) fn single_value<T>(collection: impl IntoIterator<Item = T>) -> Option
     None
 }
 
-/// Compressor/decompressor buffer size.
-const BROTLI_BUFSZ: usize = 4096;
-
-/// Compresses `buf` to `Vec` using `brotli`.
-/// Note that it handles an empty `buf` as a special value that remains empty after compression,
-/// otherwise brotli would add its metadata to it which is not nice because this function is used
-/// for compression of strings stored in the db and empty strings are common there. This approach is
-/// not strictly correct because nowhere in the brotli documentation is said that an empty buffer
-/// can't be a result of compression of some input, but i think this will never break.
-pub(crate) fn buf_compress(buf: &[u8]) -> Result<Vec<u8>> {
-    if buf.is_empty() {
-        return Ok(Vec::new());
-    }
-    // level 4 is 2x faster than level 6 (and 54x faster than 10, for comparison).
-    // with the adaptiveness, we aim to not slow down processing
-    // single large files too much, esp. on low-budget devices.
-    // in tests (see #4129), this makes a difference, without compressing much worse.
-    let q: u32 = if buf.len() > 1_000_000 { 4 } else { 6 };
-    let lgwin: u32 = 22; // log2(LZ77 window size), it's the default for brotli CLI tool.
-    let mut compressor = brotli::CompressorWriter::new(Vec::new(), BROTLI_BUFSZ, q, lgwin);
-    compressor.write_all(buf)?;
-    Ok(compressor.into_inner())
-}
-
-/// Decompresses `buf` to `Vec` using `brotli`.
-/// See `buf_compress()` for why we don't pass an empty buffer to brotli decompressor.
-pub(crate) fn buf_decompress(buf: &[u8]) -> Result<Vec<u8>> {
-    if buf.is_empty() {
-        return Ok(Vec::new());
-    }
-    let mut decompressor = brotli::DecompressorWriter::new(Vec::new(), BROTLI_BUFSZ);
-    decompressor.write_all(buf)?;
-    decompressor.flush()?;
-    Ok(mem::take(decompressor.get_mut()))
-}
-
-const RTLO_CHARACTERS: [char; 5] = ['\u{202A}', '\u{202B}', '\u{202C}', '\u{202D}', '\u{202E}'];
-/// This method strips all occurances of the RTLO Unicode character.
-/// [Why is this needed](https://github.com/deltachat/deltachat-core-rust/issues/3479)?
-pub(crate) fn strip_rtlo_characters(input_str: &str) -> String {
-    input_str.replace(|char| RTLO_CHARACTERS.contains(&char), "")
-}
-
 #[cfg(test)]
 mod tests {
     #![allow(clippy::indexing_slicing)]
@@ -1159,17 +1103,17 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
             / 1_000;
 
         // a correct time must not add a device message
-        maybe_warn_on_bad_time(&t, timestamp_now, get_release_timestamp()).await;
+        maybe_warn_on_bad_time(&t, timestamp_now, get_provider_update_timestamp()).await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
         assert_eq!(chats.len(), 0);
 
         // we cannot find out if a date in the future is wrong - a device message is not added
-        maybe_warn_on_bad_time(&t, timestamp_future, get_release_timestamp()).await;
+        maybe_warn_on_bad_time(&t, timestamp_future, get_provider_update_timestamp()).await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
         assert_eq!(chats.len(), 0);
 
         // a date in the past must add a device message
-        maybe_warn_on_bad_time(&t, timestamp_past, get_release_timestamp()).await;
+        maybe_warn_on_bad_time(&t, timestamp_past, get_provider_update_timestamp()).await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
         assert_eq!(chats.len(), 1);
         let device_chat_id = chats.get_chat_id(0).unwrap();
@@ -1177,21 +1121,31 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         assert_eq!(msgs.len(), 1);
 
         // the message should be added only once a day - test that an hour later and nearly a day later
-        maybe_warn_on_bad_time(&t, timestamp_past + 60 * 60, get_release_timestamp()).await;
+        maybe_warn_on_bad_time(
+            &t,
+            timestamp_past + 60 * 60,
+            get_provider_update_timestamp(),
+        )
+        .await;
         let msgs = chat::get_chat_msgs(&t, device_chat_id).await.unwrap();
         assert_eq!(msgs.len(), 1);
 
         maybe_warn_on_bad_time(
             &t,
             timestamp_past + 60 * 60 * 24 - 1,
-            get_release_timestamp(),
+            get_provider_update_timestamp(),
         )
         .await;
         let msgs = chat::get_chat_msgs(&t, device_chat_id).await.unwrap();
         assert_eq!(msgs.len(), 1);
 
         // next day, there should be another device message
-        maybe_warn_on_bad_time(&t, timestamp_past + 60 * 60 * 24, get_release_timestamp()).await;
+        maybe_warn_on_bad_time(
+            &t,
+            timestamp_past + 60 * 60 * 24,
+            get_provider_update_timestamp(),
+        )
+        .await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
         assert_eq!(chats.len(), 1);
         assert_eq!(device_chat_id, chats.get_chat_id(0).unwrap());
@@ -1209,7 +1163,7 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         maybe_warn_on_outdated(
             &t,
             timestamp_now + 180 * 24 * 60 * 60,
-            get_release_timestamp(),
+            get_provider_update_timestamp(),
         )
         .await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
@@ -1219,7 +1173,7 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         maybe_warn_on_outdated(
             &t,
             timestamp_now + 365 * 24 * 60 * 60,
-            get_release_timestamp(),
+            get_provider_update_timestamp(),
         )
         .await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
@@ -1233,13 +1187,13 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         maybe_warn_on_outdated(
             &t,
             timestamp_now + (365 + 1) * 24 * 60 * 60,
-            get_release_timestamp(),
+            get_provider_update_timestamp(),
         )
         .await;
         maybe_warn_on_outdated(
             &t,
             timestamp_now + (365 + 2) * 24 * 60 * 60,
-            get_release_timestamp(),
+            get_provider_update_timestamp(),
         )
         .await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
@@ -1254,7 +1208,7 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         maybe_warn_on_outdated(
             &t,
             timestamp_now + (365 + 33) * 24 * 60 * 60,
-            get_release_timestamp(),
+            get_provider_update_timestamp(),
         )
         .await;
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
@@ -1264,18 +1218,6 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         assert_eq!(msgs.len(), test_len + 1);
     }
 
-    #[test]
-    fn test_get_release_timestamp() {
-        let timestamp_past = NaiveDateTime::new(
-            NaiveDate::from_ymd_opt(2020, 9, 9).unwrap(),
-            NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
-        )
-        .timestamp_millis()
-            / 1_000;
-        assert!(get_release_timestamp() <= time());
-        assert!(get_release_timestamp() > timestamp_past);
-    }
-
     #[test]
     fn test_remove_subject_prefix() {
         assert_eq!(remove_subject_prefix("Subject"), "Subject");