Release 1.113.0

Otherwise sending a message without plaintext part
resets the signature. It is particularly dangerous
in multidevice case, because it's easy to accidentally
reset the signature on your other device with a non-text message.

.github/workflows/ci.yml

@@ -16,11 +16,11 @@ env:
   RUSTFLAGS: -Dwarnings
 
 jobs:
-  lint:
-    name: Rustfmt and Clippy
+  lint_rust:
+    name: Lint Rust
     runs-on: ubuntu-latest
     env:
-      RUSTUP_TOOLCHAIN: 1.68.0
+      RUSTUP_TOOLCHAIN: 1.68.2
     steps:
       - uses: actions/checkout@v3
       - name: Install rustfmt and clippy
@@ -31,6 +31,8 @@ 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
@@ -64,31 +66,28 @@ jobs:
       - name: Rustdoc
         run: cargo doc --document-private-items --no-deps
 
-  build_and_test:
-    name: Build and test
+  rust_tests:
+    name: Rust tests
     strategy:
-      fail-fast: false
       matrix:
         include:
-          # Currently used Rust version.
           - os: ubuntu-latest
-            rust: 1.68.0
-            python: 3.9
+            rust: 1.68.2
           - os: windows-latest
-            rust: 1.68.0
-            python: false # Python bindings compilation on Windows is not supported.
+            rust: 1.68.2
+          - os: macos-latest
+            rust: 1.68.2
 
-          # Minimum Supported Rust Version = 1.64.0
+          # Minimum Supported Rust Version = 1.65.0
           #
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
           # built.
           - os: ubuntu-latest
-            rust: 1.64.0
-            python: 3.7
+            rust: 1.65.0
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v3
 
       - name: Install Rust ${{ matrix.rust }}
         run: rustup toolchain install --profile minimal ${{ matrix.rust }}
@@ -97,64 +96,176 @@ 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 lint,mypy,doc,py3
+        run: tox -e mypy,doc,py
 
-      - name: Build deltachat-rpc-server
-        if: ${{ matrix.python }}
-        run: cargo build -p deltachat-rpc-server
+  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: 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 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
+        run: tox -e py

.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, aarch64 and armv7 Linux
+    name: Cross-compile deltachat-rpc-server for x86_64, i686, aarch64 and armv7 Linux
     runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v3
@@ -30,6 +30,13 @@ 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:
@@ -84,35 +91,15 @@ jobs:
       contents: write
     runs-on: "ubuntu-latest"
     steps:
-      - name: Download deltachat-rpc-server-x86_64
+      - name: Download built binaries
         uses: "actions/download-artifact@v3"
-        with:
-          name: "deltachat-rpc-server-x86_64"
-          path: "dist/deltachat-rpc-server-x86_64"
 
-      - name: Download deltachat-rpc-server-aarch64
-        uses: "actions/download-artifact@v3"
-        with:
-          name: "deltachat-rpc-server-aarch64"
-          path: "dist/deltachat-rpc-server-aarch64"
-
-      - name: Download deltachat-rpc-server-armv7
-        uses: "actions/download-artifact@v3"
-        with:
-          name: "deltachat-rpc-server-armv7"
-          path: "dist/deltachat-rpc-server-armv7"
-
-      - name: Download deltachat-rpc-server-win32.exe
-        uses: "actions/download-artifact@v3"
-        with:
-          name: "deltachat-rpc-server-win32.exe"
-          path: "dist/deltachat-rpc-server-win32.exe"
-
-      - name: Download deltachat-rpc-server-win64.exe
-        uses: "actions/download-artifact@v3"
-        with:
-          name: "deltachat-rpc-server-win64.exe"
-          path: "dist/deltachat-rpc-server-win64.exe"
+      - name: Compose dist/ directory
+        run: |
+          mkdir dist
+          for x in x86_64 i686 aarch64 armv7 win32.exe win64.exe; do
+            mv "deltachat-rpc-server-$x"/* "dist/deltachat-rpc-server-$x"
+          done
 
       - name: List downloaded artifacts
         run: ls -l dist/
@@ -123,4 +110,4 @@ jobs:
         run: |
           gh release upload ${{ github.ref_name }} \
             --repo ${{ github.repository }} \
-            dist/deltachat-rpc-server-*
+            dist/*

CHANGELOG.md

@@ -1,18 +1,103 @@
 # Changelog
 
-## [Unreleased]
+## [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
+
+### 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
+
+## [1.112.7] - 2023-04-17
+
+### Fixes
+
+- Updated `async-imap` to v0.8.0 to fix erroneous EOF detection in long IMAP responses.
+
+## [1.112.6] - 2023-04-04
+
+### Changes
+
+- Add a device message after backup transfer #4301
+
+### Fixed
+
+- Updated `iroh` from 0.4.0 to 0.4.1 to fix transfer of large accounts with many blob files.
+
+## [1.112.5] - 2023-04-02
+
+### Fixes
+
+- Run SQL database migrations after receiving a backup from the network. #4287
+
+## [1.112.4] - 2023-03-31
+
+### Fixes
+- Fix call to `auditwheel` in `scripts/run_all.sh`.
+
+## [1.112.3] - 2023-03-30
+
+### Fixes
+- `transfer::get_backup` now frees ongoing process when cancelled. #4249
+
+## [1.112.2] - 2023-03-30
+
+### Changes
+- Update iroh, remove `default-net` from `[patch.crates-io]` section.
+- transfer backup: Connect to multiple provider addresses concurrently.  This should speed up connection time significantly on the getter side.  #4240
+- Make sure BackupProvider is cancelled on drop (or `dc_backup_provider_unref`).  The BackupProvider will now always finish with an IMEX event of 1000 or 0, previously it would sometimes finished with 1000 (success) when it really was 0 (failure). #4242
+
+### Fixes
+- Do not return media from trashed messages in the "All media" view. #4247
+
+## [1.112.1] - 2023-03-27
+
+### Changes
+- Add support for `--version` argument to `deltachat-rpc-server`. #4224
+  It can be used to check the installed version without starting the server.
+
+### Fixes
+- deltachat-rpc-client: fix bug in `Chat.send_message()`: invalid `MessageData` field `quotedMsg` instead of `quotedMsgId`
+- `receive_imf`: Mark special messages as seen. Exactly: delivery reports, webxdc status updates. #4230
+
+
+## [1.112.0] - 2023-03-23
 
 ### Changes
-- "full message view" not needed because of footers that go to contact status #4151
-- Pick up system's light/dark mode in generated message HTML #4150
-- Support non-persistent configuration with DELTACHAT_* env
-- Print deltachat-repl errors with causes. #4166
 - Increase MSRV to 1.64. #4167
 - Core takes care of stopping and re-starting IO itself where needed,
-  e.g. during backup creation.  It is no longer needed to call
-  dc_stop_io().  dc_start_io() can now be called at any time without
-  harm. #4138
-- More accurate maybe_add_bcc_self device message text #4175
+  e.g. during backup creation.
+  It is no longer needed to call `dc_stop_io()`.
+  `dc_start_io()` can now be called at any time without harm. #4138
+- Pick up system's light/dark mode in generated message HTML. #4150
+- More accurate `maybe_add_bcc_self` device message text. #4175
+- "Full message view" not needed because of footers that go to contact status. #4151
+- Support non-persistent configuration with `DELTACHAT_*` env. #4154
+- Print deltachat-repl errors with causes. #4166
 
 ### Fixes
 - Fix segmentation fault if `dc_context_unref()` is called during
@@ -23,6 +108,11 @@
 - Do not emit "Failed to run incremental vacuum" warnings on success. #4160
 - Ability to send backup over network and QR code to setup second device #4007
 - Disable buffering during STARTTLS setup. #4190
+- Add `DC_EVENT_IMAP_INBOX_IDLE` event to wait until the account
+  is ready for testing.
+  It is used to fix race condition between fetching
+  existing messages and starting the test. #4208
+
 
 ## [1.111.0] - 2023-03-05
 
@@ -153,7 +243,6 @@
 - Do not treat invalid email addresses as an exception #3942
 - Add timeouts to HTTP requests #3948
 
-
 ## 1.105.0
 
 ### Changes
@@ -239,7 +328,6 @@
 - Disable read timeout during IMAP IDLE #3826
 - Bots automatically accept mailing lists #3831
 
-
 ## 1.102.0
 
 ### Changes
@@ -2314,5 +2402,13 @@ For a full list of changes, please see our closed Pull Requests:
 
 https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 
-[unreleased]: https://github.com/deltachat/deltachat-core-rust/compare/v1.111.0...HEAD
 [1.111.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.110.0...v1.111.0
+[1.112.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.111.0...v1.112.0
+[1.112.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.0...v1.112.1
+[1.112.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.1...v1.112.2
+[1.112.3]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.2...v1.112.3
+[1.112.4]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.3...v1.112.4
+[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.113.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.112.7...v1.113.0

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "deltachat"
-version = "1.111.0"
+version = "1.113.0"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.64"
+rust-version = "1.65"
 
 [profile.dev]
 debug = 0
@@ -25,7 +25,6 @@ panic = 'abort'
 opt-level = "z"
 
 [patch.crates-io]
-default-net = { git = "https://github.com/dignifiedquire/default-net.git", branch="feat-android" }
 quinn-udp = { git = "https://github.com/quinn-rs/quinn", branch="main" }
 quinn-proto = { git = "https://github.com/quinn-rs/quinn", branch="main" }
 
@@ -36,13 +35,13 @@ ratelimit = { path = "./deltachat-ratelimit" }
 
 anyhow = "1"
 async-channel = "1.8.0"
-async-imap = { git = "https://github.com/async-email/async-imap", branch = "master", default-features = false, features = ["runtime-tokio"] }
+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.9", default-features = false, features = ["deflate"] }
+async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
 backtrace = "0.3"
 base64 = "0.21"
-bitflags = "1.3"
+brotli = "3.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" }
@@ -52,9 +51,8 @@ futures = "0.3"
 futures-lite = "1.12.0"
 hex = "0.4.0"
 humansize = "2"
-image = { version = "0.24.5", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
-# iroh = { version = "0.3.0", default-features = false }
-iroh = { git = 'https://github.com/n0-computer/iroh', branch = "flub/ticket-multiple-addrs" }
+image = { version = "0.24.6", 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" }
 libc = "0.2"
@@ -65,14 +63,14 @@ num-traits = "0.2"
 once_cell = "1.17.0"
 percent-encoding = "2.2"
 parking_lot = "0.12"
-pgp = { version = "0.9", default-features = false }
+pgp = { version = "0.10", default-features = false }
 pretty_env_logger = { version = "0.4", optional = true }
 qrcodegen = "1.7.0"
-quick-xml = "0.27"
+quick-xml = "0.28"
 rand = "0.8"
 regex = "1.7"
-reqwest = { version = "0.11.14", features = ["json"] }
-rusqlite = { version = "0.28", features = ["sqlcipher"] }
+reqwest = { version = "0.11.16", features = ["json"] }
+rusqlite = { version = "0.29", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
 sanitize-filename = "0.4"
 serde_json = "1.0"
@@ -85,10 +83,11 @@ strum_macros = "0.24"
 tagger = "4.3.4"
 textwrap = "0.16.0"
 thiserror = "1"
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 tokio-io-timeout = "1.2.0"
 tokio-stream = { version = "0.1.11", features = ["fs"] }
 tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
-tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
+tokio-util = "0.7.7"
 toml = "0.7"
 trust-dns-resolver = "0.22"
 url = "2"
@@ -102,7 +101,7 @@ log = "0.4"
 pretty_env_logger = "0.4"
 proptest = { version = "1", default-features = false, features = ["std"] }
 tempfile = "3"
-testdir = "0.7.2"
+testdir = "0.7.3"
 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.111.0"
+version = "1.113.0"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
@@ -23,7 +23,7 @@ serde_json = "1.0"
 tokio = { version = "1", features = ["rt-multi-thread"] }
 anyhow = "1"
 thiserror = "1"
-rand = "0.7"
+rand = "0.8"
 once_cell = "1.17.0"
 
 [features]

deltachat-ffi/deltachat.h

@@ -72,7 +72,6 @@ typedef struct _dc_event_emitter dc_accounts_event_emitter_t;
  *
  * The example above uses "pthreads",
  * however, you can also use anything else for thread handling.
- * All deltachat-core functions, unless stated otherwise, are thread-safe.
  *
  * Now you can **configure the context:**
  *
@@ -142,6 +141,72 @@ typedef struct _dc_event_emitter dc_accounts_event_emitter_t;
  * ~~~
  *
  *
+ * ## Thread safety
+ *
+ * All deltachat-core functions, unless stated otherwise, are thread-safe.
+ * In particular, it is safe to pass the same dc_context_t pointer
+ * to multiple functions running concurrently in different threads.
+ *
+ * All the functions are guaranteed not to use the reference passed to them
+ * after returning. If the function spawns a long-running process,
+ * such as dc_configure() or dc_imex(), it will ensure that the objects
+ * passed to them are not deallocated as long as they are needed.
+ * For example, it is safe to call dc_imex(context, ...) and
+ * call dc_context_unref(context) immediately after return from dc_imex().
+ * It is however **not safe** to call dc_context_unref(context) concurrently
+ * until dc_imex() returns, because dc_imex() may have not increased
+ * the reference count of dc_context_t yet.
+ *
+ * This means that the context may be still in use after
+ * dc_context_unref() call.
+ * For example, it is possible to start the import/export process,
+ * call dc_context_unref(context) immediately after
+ * and observe #DC_EVENT_IMEX_PROGRESS events via the event emitter.
+ * Once dc_get_next_event() returns NULL,
+ * it is safe to terminate the application.
+ *
+ * It is recommended to create dc_context_t in the main thread
+ * and only call dc_context_unref() once other threads that may use it,
+ * such as the event loop thread, are terminated.
+ * Common mistake is to use dc_context_unref() as a way
+ * to cause dc_get_next_event() return NULL and terminate event loop this way.
+ * If event loop thread is inside a function taking dc_context_t
+ * as an argument at the moment dc_context_unref() is called on the main thread,
+ * the behavior is undefined.
+ *
+ * Recommended way to safely terminate event loop
+ * and shutdown the application is
+ * to use a boolean variable
+ * indicating that the event loop should stop
+ * 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.
+ * 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().
+ * 5. Keep calling dc_get_next_event() in a loop until it returns NULL,
+ *    indicating that the contexts are deallocated.
+ * 6. Terminate the application.
+ *
+ * When using C API via FFI in runtimes that use automatic memory management,
+ * such as CPython, JVM or Node.js, take care to ensure the correct
+ * shutdown order and avoid calling dc_context_unref() or dc_accounts_unref()
+ * on the objects still in use in other threads,
+ * e.g. by keeping a reference to the wrapper object.
+ * The details depend on the runtime being used.
+ *
+ *
  * ## Class reference
  *
  * For a class reference, see the "Classes" link atop.
@@ -397,6 +462,16 @@ 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.
@@ -1283,6 +1358,56 @@ 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
@@ -1882,6 +2007,11 @@ 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
@@ -2715,6 +2845,12 @@ void dc_backup_provider_wait (dc_backup_provider_t* backup_provider);
 /**
  * Frees a dc_backup_provider_t object.
  *
+ * If the provider has not yet finished, as indicated by
+ * dc_backup_provider_wait() or the #DC_EVENT_IMEX_PROGRESS event with value
+ * of 0 (failed) or 1000 (succeeded), this will also abort any in-progress
+ * transfer.  If this aborts the provider a #DC_EVENT_IMEX_PROGRESS event with
+ * value 0 (failed) will be emitted.
+ *
  * @memberof dc_backup_provider_t
  * @param backup_provider The backup provider object as created by
  *    dc_backup_provider_new().
@@ -5705,6 +5841,14 @@ void dc_event_unref(dc_event_t* event);
  */
 #define DC_EVENT_IMAP_MESSAGE_MOVED   105
 
+/**
+ * Emitted before going into IDLE on the Inbox folder.
+ *
+ * @param data1 0
+ * @param data2 0
+ */
+#define DC_EVENT_IMAP_INBOX_IDLE 106
+
 /**
  * Emitted when a new blob file was successfully written
  *
@@ -6990,6 +7134,16 @@ void dc_event_unref(dc_event_t* event);
 /// `%1$s` will be replaced by name and address of the contact.
 #define DC_STR_PROTECTION_DISABLED_BY_OTHER 161
 
+/// "Scan to set up second device for %1$s"
+///
+/// `%1$s` will be replaced by name and address of the account.
+#define DC_STR_BACKUP_TRANSFER_QR 162
+
+/// "Account transferred to your second device."
+///
+/// Used as a device message after a successful backup transfer.
+#define DC_STR_BACKUP_TRANSFER_MSG_BODY 163
+
 /**
  * @}
  */

deltachat-ffi/src/lib.rs

@@ -160,7 +160,8 @@ pub unsafe extern "C" fn dc_context_open(
     let ctx = &*context;
     let passphrase = to_string_lossy(passphrase);
     block_on(ctx.open(passphrase))
-        .log_err(ctx, "dc_context_open() failed")
+        .context("dc_context_open() failed")
+        .log_err(ctx)
         .map(|b| b as libc::c_int)
         .unwrap_or(0)
 }
@@ -216,16 +217,18 @@ 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!("Can't set {key} to {value:?}"))
-                .log_err(ctx, "dc_set_config() failed")
+                .with_context(|| format!("dc_set_config failed: Can't set {key} to {value:?}"))
+                .log_err(ctx)
                 .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!("Can't set {key} to {value:?}"))
-                    .log_err(ctx, "dc_set_config() failed")
+                    .with_context(|| {
+                        format!("dc_set_config() failed: Can't set {key} to {value:?}")
+                    })
+                    .log_err(ctx)
                     .is_ok() as libc::c_int,
                 Err(_) => {
                     warn!(ctx, "dc_set_config(): invalid key");
@@ -253,7 +256,8 @@ pub unsafe extern "C" fn dc_get_config(
         if key.starts_with("ui.") {
             ctx.get_ui_config(&key)
                 .await
-                .log_err(ctx, "Can't get ui-config")
+                .context("Can't get ui-config")
+                .log_err(ctx)
                 .unwrap_or_default()
                 .unwrap_or_default()
                 .strdup()
@@ -262,7 +266,8 @@ pub unsafe extern "C" fn dc_get_config(
                 Ok(key) => ctx
                     .get_config(key)
                     .await
-                    .log_err(ctx, "Can't get config")
+                    .context("Can't get config")
+                    .log_err(ctx)
                     .unwrap_or_default()
                     .unwrap_or_default()
                     .strdup(),
@@ -414,7 +419,8 @@ pub unsafe extern "C" fn dc_get_oauth2_url(
     block_on(async move {
         match oauth2::get_oauth2_url(ctx, &addr, &redirect)
             .await
-            .log_err(ctx, "dc_get_oauth2_url failed")
+            .context("dc_get_oauth2_url failed")
+            .log_err(ctx)
         {
             Ok(Some(res)) => res.strdup(),
             Ok(None) | Err(_) => ptr::null_mut(),
@@ -423,7 +429,12 @@ pub unsafe extern "C" fn dc_get_oauth2_url(
 }
 
 fn spawn_configure(ctx: Context) {
-    spawn(async move { ctx.configure().await.log_err(&ctx, "Configure failed") });
+    spawn(async move {
+        ctx.configure()
+            .await
+            .context("Configure failed")
+            .log_err(&ctx)
+    });
 }
 
 #[no_mangle]
@@ -448,7 +459,8 @@ pub unsafe extern "C" fn dc_is_configured(context: *mut dc_context_t) -> libc::c
     block_on(async move {
         ctx.is_configured()
             .await
-            .log_err(ctx, "failed to get configured state")
+            .context("failed to get configured state")
+            .log_err(ctx)
             .unwrap_or_default() as libc::c_int
     })
 }
@@ -500,6 +512,7 @@ pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int
         EventType::SmtpMessageSent(_) => 103,
         EventType::ImapMessageDeleted(_) => 104,
         EventType::ImapMessageMoved(_) => 105,
+        EventType::ImapInboxIdle => 106,
         EventType::NewBlobFile(_) => 150,
         EventType::DeletedBlobFile(_) => 151,
         EventType::Warning(_) => 300,
@@ -544,6 +557,7 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
         | EventType::SmtpMessageSent(_)
         | EventType::ImapMessageDeleted(_)
         | EventType::ImapMessageMoved(_)
+        | EventType::ImapInboxIdle
         | EventType::NewBlobFile(_)
         | EventType::DeletedBlobFile(_)
         | EventType::Warning(_)
@@ -594,6 +608,7 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
         | EventType::SmtpMessageSent(_)
         | EventType::ImapMessageDeleted(_)
         | EventType::ImapMessageMoved(_)
+        | EventType::ImapInboxIdle
         | EventType::NewBlobFile(_)
         | EventType::DeletedBlobFile(_)
         | EventType::Warning(_)
@@ -653,6 +668,7 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
         EventType::MsgsChanged { .. }
         | EventType::ReactionsChanged { .. }
         | EventType::IncomingMsg { .. }
+        | EventType::ImapInboxIdle
         | EventType::MsgsNoticed(_)
         | EventType::MsgDelivered { .. }
         | EventType::MsgFailed { .. }
@@ -786,7 +802,8 @@ pub unsafe extern "C" fn dc_preconfigure_keypair(
         key::store_self_keypair(ctx, &keypair, key::KeyPairUse::Default).await?;
         Ok::<_, anyhow::Error>(1)
     })
-    .log_err(ctx, "Failed to save keypair")
+    .context("Failed to save keypair")
+    .log_err(ctx)
     .unwrap_or(0)
 }
 
@@ -813,7 +830,8 @@ 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
-            .log_err(ctx, "Failed to get chatlist")
+            .context("Failed to get chatlist")
+            .log_err(ctx)
         {
             Ok(list) => {
                 let ffi_list = ChatlistWrapper { context, list };
@@ -838,7 +856,8 @@ 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
-            .log_err(ctx, "Failed to create chat from contact_id")
+            .context("Failed to create chat from contact_id")
+            .log_err(ctx)
             .map(|id| id.to_u32())
             .unwrap_or(0)
     })
@@ -858,7 +877,8 @@ 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
-            .log_err(ctx, "Failed to get chat for contact_id")
+            .context("Failed to get chat for contact_id")
+            .log_err(ctx)
             .unwrap_or_default() // unwraps the Result
             .map(|id| id.to_u32())
             .unwrap_or(0) // unwraps the Option
@@ -1000,7 +1020,8 @@ 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)))
-        .log_err(ctx, "failed dc_get_msg_reactions() call")
+        .context("failed dc_get_msg_reactions() call")
+        .log_err(ctx)
     {
         reactions
     } else {
@@ -1028,7 +1049,8 @@ pub unsafe extern "C" fn dc_send_webxdc_status_update(
         &to_string_lossy(json),
         &to_string_lossy(descr),
     ))
-    .log_err(ctx, "Failed to send webxdc update")
+    .context("Failed to send webxdc update")
+    .log_err(ctx)
     .is_ok() as libc::c_int
 }
 
@@ -1247,7 +1269,8 @@ pub unsafe extern "C" fn dc_get_fresh_msgs(
         let arr = dc_array_t::from(
             ctx.get_fresh_msgs()
                 .await
-                .log_err(ctx, "Failed to get fresh messages")
+                .context("Failed to get fresh messages")
+                .log_err(ctx)
                 .unwrap_or_default()
                 .iter()
                 .map(|msg_id| msg_id.to_u32())
@@ -1257,6 +1280,50 @@ 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() {
@@ -1268,7 +1335,8 @@ 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
-            .log_err(ctx, "Failed marknoticed chat")
+            .context("Failed marknoticed chat")
+            .log_err(ctx)
             .unwrap_or(())
     })
 }
@@ -1410,7 +1478,8 @@ pub unsafe extern "C" fn dc_set_chat_visibility(
         ChatId::new(chat_id)
             .set_visibility(ctx, visibility)
             .await
-            .log_err(ctx, "Failed setting chat visibility")
+            .context("Failed setting chat visibility")
+            .log_err(ctx)
             .unwrap_or(())
     })
 }
@@ -1427,7 +1496,9 @@ pub unsafe extern "C" fn dc_delete_chat(context: *mut dc_context_t, chat_id: u32
         ChatId::new(chat_id)
             .delete(ctx)
             .await
-            .ok_or_log_msg(ctx, "Failed chat delete");
+            .context("Failed chat delete")
+            .log_err(ctx)
+            .ok();
     })
 }
 
@@ -1443,7 +1514,9 @@ pub unsafe extern "C" fn dc_block_chat(context: *mut dc_context_t, chat_id: u32)
         ChatId::new(chat_id)
             .block(ctx)
             .await
-            .ok_or_log_msg(ctx, "Failed chat block");
+            .context("Failed chat block")
+            .log_err(ctx)
+            .ok();
     })
 }
 
@@ -1459,7 +1532,9 @@ pub unsafe extern "C" fn dc_accept_chat(context: *mut dc_context_t, chat_id: u32
         ChatId::new(chat_id)
             .accept(ctx)
             .await
-            .ok_or_log_msg(ctx, "Failed chat accept");
+            .context("Failed chat accept")
+            .log_err(ctx)
+            .ok();
     })
 }
 
@@ -1557,7 +1632,8 @@ pub unsafe extern "C" fn dc_create_group_chat(
     block_on(async move {
         chat::create_group_chat(ctx, protect, &to_string_lossy(name))
             .await
-            .log_err(ctx, "Failed to create group chat")
+            .context("Failed to create group chat")
+            .log_err(ctx)
             .map(|id| id.to_u32())
             .unwrap_or(0)
     })
@@ -1571,7 +1647,8 @@ pub unsafe extern "C" fn dc_create_broadcast_list(context: *mut dc_context_t) ->
     }
     let ctx = &*context;
     block_on(chat::create_broadcast_list(ctx))
-        .log_err(ctx, "Failed to create broadcast list")
+        .context("Failed to create broadcast list")
+        .log_err(ctx)
         .map(|id| id.to_u32())
         .unwrap_or(0)
 }
@@ -1593,7 +1670,8 @@ pub unsafe extern "C" fn dc_is_contact_in_chat(
         ChatId::new(chat_id),
         ContactId::new(contact_id),
     ))
-    .log_err(ctx, "is_contact_in_chat failed")
+    .context("is_contact_in_chat failed")
+    .log_err(ctx)
     .unwrap_or_default() as libc::c_int
 }
 
@@ -1614,7 +1692,8 @@ pub unsafe extern "C" fn dc_add_contact_to_chat(
         ChatId::new(chat_id),
         ContactId::new(contact_id),
     ))
-    .log_err(ctx, "Failed to add contact")
+    .context("Failed to add contact")
+    .log_err(ctx)
     .is_ok() as libc::c_int
 }
 
@@ -1635,7 +1714,8 @@ pub unsafe extern "C" fn dc_remove_contact_from_chat(
         ChatId::new(chat_id),
         ContactId::new(contact_id),
     ))
-    .log_err(ctx, "Failed to remove contact")
+    .context("Failed to remove contact")
+    .log_err(ctx)
     .is_ok() as libc::c_int
 }
 
@@ -1754,7 +1834,8 @@ 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 })
-        .log_err(ctx, "Failed to get ephemeral timer")
+        .context("Failed to get ephemeral timer")
+        .log_err(ctx)
         .unwrap_or_default()
         .to_u32()
 }
@@ -1775,7 +1856,8 @@ pub unsafe extern "C" fn dc_set_chat_ephemeral_timer(
         ChatId::new(chat_id)
             .set_ephemeral_timer(ctx, EphemeralTimer::from_u32(timer))
             .await
-            .log_err(ctx, "Failed to set ephemeral timer")
+            .context("Failed to set ephemeral timer")
+            .log_err(ctx)
             .is_ok() as libc::c_int
     })
 }
@@ -1851,7 +1933,8 @@ 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))
-        .log_err(ctx, "failed dc_delete_msgs() call")
+        .context("failed dc_delete_msgs() call")
+        .log_err(ctx)
         .ok();
 }
 
@@ -1915,7 +1998,8 @@ pub unsafe extern "C" fn dc_markseen_msgs(
     let ctx = &*context;
 
     block_on(message::markseen_msgs(ctx, msg_ids))
-        .log_err(ctx, "failed dc_markseen_msgs() call")
+        .context("failed dc_markseen_msgs() call")
+        .log_err(ctx)
         .ok();
 }
 
@@ -1957,7 +2041,8 @@ 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))
-        .log_err(ctx, "Failed to download message fully.")
+        .context("Failed to download message fully.")
+        .log_err(ctx)
         .ok();
 }
 
@@ -2005,7 +2090,8 @@ pub unsafe extern "C" fn dc_create_contact(
     let name = to_string_lossy(name);
 
     block_on(Contact::create(ctx, &name, &to_string_lossy(addr)))
-        .log_err(ctx, "Cannot create contact")
+        .context("Cannot create contact")
+        .log_err(ctx)
         .map(|id| id.to_u32())
         .unwrap_or(0)
 }
@@ -2082,7 +2168,8 @@ pub unsafe extern "C" fn dc_get_blocked_contacts(
         Box::into_raw(Box::new(dc_array_t::from(
             Contact::get_all_blocked(ctx)
                 .await
-                .log_err(ctx, "Can't get blocked contacts")
+                .context("Can't get blocked contacts")
+                .log_err(ctx)
                 .unwrap_or_default()
                 .iter()
                 .map(|id| id.to_u32())
@@ -2107,11 +2194,15 @@ pub unsafe extern "C" fn dc_block_contact(
         if block == 0 {
             Contact::unblock(ctx, contact_id)
                 .await
-                .ok_or_log_msg(ctx, "Can't unblock contact");
+                .context("Can't unblock contact")
+                .log_err(ctx)
+                .ok();
         } else {
             Contact::block(ctx, contact_id)
                 .await
-                .ok_or_log_msg(ctx, "Can't block contact");
+                .context("Can't block contact")
+                .log_err(ctx)
+                .ok();
         }
     });
 }
@@ -2184,7 +2275,8 @@ fn spawn_imex(ctx: Context, what: imex::ImexMode, param1: String, passphrase: Op
     spawn(async move {
         imex::imex(&ctx, what, param1.as_ref(), passphrase)
             .await
-            .log_err(&ctx, "IMEX failed")
+            .context("IMEX failed")
+            .log_err(&ctx)
     });
 }
 
@@ -2370,7 +2462,8 @@ pub unsafe extern "C" fn dc_join_securejoin(
         securejoin::join_securejoin(ctx, &to_string_lossy(qr))
             .await
             .map(|chatid| chatid.to_u32())
-            .log_err(ctx, "failed dc_join_securejoin() call")
+            .context("failed dc_join_securejoin() call")
+            .log_err(ctx)
             .unwrap_or_default()
     })
 }
@@ -2392,7 +2485,8 @@ pub unsafe extern "C" fn dc_send_locations_to_chat(
         ChatId::new(chat_id),
         seconds as i64,
     ))
-    .log_err(ctx, "Failed dc_send_locations_to_chat()")
+    .context("Failed dc_send_locations_to_chat()")
+    .log_err(ctx)
     .ok();
 }
 
@@ -2475,7 +2569,8 @@ pub unsafe extern "C" fn dc_delete_all_locations(context: *mut dc_context_t) {
     block_on(async move {
         location::delete_all(ctx)
             .await
-            .log_err(ctx, "Failed to delete locations")
+            .context("Failed to delete locations")
+            .log_err(ctx)
             .ok()
     });
 }
@@ -2759,7 +2854,8 @@ pub unsafe extern "C" fn dc_chatlist_get_summary(
             .list
             .get_summary(ctx, index, maybe_chat)
             .await
-            .log_err(ctx, "get_summary failed")
+            .context("get_summary failed")
+            .log_err(ctx)
             .unwrap_or_default();
         Box::into_raw(Box::new(summary.into()))
     })
@@ -2787,7 +2883,8 @@ pub unsafe extern "C" fn dc_chatlist_get_summary2(
         msg_id,
         None,
     ))
-    .log_err(ctx, "get_summary2 failed")
+    .context("get_summary2 failed")
+    .log_err(ctx)
     .unwrap_or_default();
     Box::into_raw(Box::new(summary.into()))
 }
@@ -2970,7 +3067,8 @@ 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))
-        .log_err(ctx, "can_send failed")
+        .context("can_send failed")
+        .log_err(ctx)
         .unwrap_or_default() as libc::c_int
 }
 
@@ -3415,7 +3513,8 @@ 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))
-        .log_err(ctx, "dc_msg_get_summary failed")
+        .context("dc_msg_get_summary failed")
+        .log_err(ctx)
         .unwrap_or_default();
     Box::into_raw(Box::new(summary.into()))
 }
@@ -3433,7 +3532,8 @@ 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))
-        .log_err(ctx, "dc_msg_get_summarytext failed")
+        .context("dc_msg_get_summarytext failed")
+        .log_err(ctx)
         .unwrap_or_default();
     match usize::try_from(approx_characters) {
         Ok(chars) => summary.truncated_text(chars).strdup(),
@@ -3700,7 +3800,9 @@ pub unsafe extern "C" fn dc_msg_latefiling_mediasize(
             .message
             .latefiling_mediasize(ctx, width, height, duration)
     })
-    .ok_or_log_msg(ctx, "Cannot set media size");
+    .context("Cannot set media size")
+    .log_err(ctx)
+    .ok();
 }
 
 #[no_mangle]
@@ -3739,7 +3841,8 @@ 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
-            .log_err(&*ffi_msg.context, "failed to set quote")
+            .context("failed to set quote")
+            .log_err(&*ffi_msg.context)
             .ok();
     });
 }
@@ -3770,7 +3873,8 @@ pub unsafe extern "C" fn dc_msg_get_quoted_msg(msg: *const dc_msg_t) -> *mut dc_
             .message
             .quoted_message(context)
             .await
-            .log_err(context, "failed to get quoted message")
+            .context("failed to get quoted message")
+            .log_err(context)
             .unwrap_or(None)
     });
 
@@ -3793,7 +3897,8 @@ pub unsafe extern "C" fn dc_msg_get_parent(msg: *const dc_msg_t) -> *mut dc_msg_
             .message
             .parent(context)
             .await
-            .log_err(context, "failed to get parent message")
+            .context("failed to get parent message")
+            .log_err(context)
             .unwrap_or(None)
     });
 
@@ -3984,7 +4089,8 @@ 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))
-        .log_err(ctx, "is_verified failed")
+        .context("is_verified failed")
+        .log_err(ctx)
         .unwrap_or_default() as libc::c_int
 }
 
@@ -3999,7 +4105,8 @@ 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))
-        .log_err(ctx, "failed to get verifier for contact")
+        .context("failed to get verifier for contact")
+        .log_err(ctx)
         .unwrap_or_default()
         .strdup()
 }
@@ -4013,7 +4120,8 @@ 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))
-        .log_err(ctx, "failed to get verifier")
+        .context("failed to get verifier")
+        .log_err(ctx)
         .unwrap_or_default()
         .unwrap_or_default();
 
@@ -4165,8 +4273,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())
 }
@@ -4182,8 +4290,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()
@@ -4201,8 +4309,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()
@@ -4218,14 +4326,18 @@ 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();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn dc_backup_provider_unref(provider: *mut dc_backup_provider_t) {
+    if provider.is_null() {
+        eprintln!("ignoring careless call to dc_backup_provider_unref()");
+        return;
+    }
     drop(Box::from_raw(provider));
 }
 
@@ -4240,17 +4352,28 @@ pub unsafe extern "C" fn dc_receive_backup(
     }
     let ctx = &*context;
     let qr_text = to_string_lossy(qr);
-    let qr = match block_on(qr::check_qr(ctx, &qr_text)).log_err(ctx, "Invalid QR code") {
+    receive_backup(ctx.clone(), qr_text)
+}
+
+// Because this is a long-running operation make sure we own the Context.  This stops a FFI
+// 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))
+        .context("Invalid QR code")
+        .log_err(&ctx)
+        .set_last_error(&ctx)
+    {
         Ok(qr) => qr,
         Err(_) => return 0,
     };
-    spawn(async move {
-        imex::get_backup(ctx, qr)
-            .await
-            .log_err(ctx, "Get backup failed")
-            .ok();
-    });
-    1
+    match block_on(imex::get_backup(&ctx, qr))
+        .context("Get backup failed")
+        .log_err(&ctx)
+        .set_last_error(&ctx)
+    {
+        Ok(_) => 1,
+        Err(_) => 0,
+    }
 }
 
 trait ResultExt<T, E> {
@@ -4297,8 +4420,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()
     /// ```
@@ -4385,7 +4508,8 @@ 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
-            .log_err(ctx, "Can't get config")
+            .context("Can't get config")
+            .log_err(ctx)
     });
 
     match socks5_enabled {

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.111.0"
+version = "1.113.0"
 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.26" }
-serde_json = "1.0.91"
+futures = { version = "0.3.28" }
+serde_json = "1.0.95"
 yerpc = { version = "0.4.3", features = ["anyhow_expose"] }
 typescript-type-def = { version = "0.5.5", features = ["json_value"] }
-tokio = { version = "1.25.0" }
+tokio = { version = "1.27.0" }
 sanitize-filename = "0.4"
-walkdir = "2.3.2"
+walkdir = "2.3.3"
 base64 = "0.21"
 
 # optional dependencies
-axum = { version = "0.6.11", optional = true, features = ["ws"] }
+axum = { version = "0.6.12", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.25.0", features = ["full", "rt-multi-thread"] }
+tokio = { version = "1.27.0", features = ["full", "rt-multi-thread"] }
 
 
 [features]

deltachat-jsonrpc/src/api/events.rs

@@ -47,6 +47,9 @@ pub enum JSONRPCEventType {
         msg: String,
     },
 
+    /// Emitted before going into IDLE on the Inbox folder.
+    ImapInboxIdle,
+
     /// Emitted when an new file in the $BLOBDIR was created
     NewBlobFile {
         file: String,
@@ -293,6 +296,7 @@ impl From<EventType> for JSONRPCEventType {
             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 },

deltachat-jsonrpc/src/api/mod.rs

@@ -453,6 +453,49 @@ 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
@@ -944,6 +987,11 @@ 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?;
@@ -1082,17 +1130,17 @@ impl CommandApi {
     }
 
     /// Search messages containing the given query string.
-    /// Searching can be done globally (chat_id=0) or in a specified chat only (chat_id set).
+    /// Searching can be done globally (chat_id=None) or in a specified chat only (chat_id set).
     ///
-    /// Global chat results are typically displayed using dc_msg_get_summary(), chat
-    /// search results may just hilite the corresponding messages and present a
+    /// Global search results are typically displayed using dc_msg_get_summary(), chat
+    /// search results may just highlight the corresponding messages and present a
     /// prev/next button.
     ///
-    /// 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.
+    /// 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.
     async fn search_messages(
         &self,
         account_id: u32,
@@ -1701,6 +1749,15 @@ 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/typescript/package.json

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

deltachat-repl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.111.0"
+version = "1.113.0"
 license = "MPL-2.0"
 edition = "2021"
 
@@ -8,10 +8,10 @@ edition = "2021"
 ansi_term = "0.12.1"
 anyhow = "1"
 deltachat = { path = "..", features = ["internals"]}
-dirs = "4"
+dirs = "5"
 log = "0.4.16"
 pretty_env_logger = "0.4"
-rusqlite = "0.28"
+rusqlite = "0.29"
 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.ok_or_log(&context);
+            sql::housekeeping(&context).await.log_err(&context).ok();
         }
         "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
+from deltachat_rpc_client import DeltaChat, EventType, Rpc, SpecialContactId
 
 
 async def main():
@@ -30,9 +30,9 @@ async def main():
             await deltachat.start_io()
 
         async def process_messages():
-            for message in await account.get_fresh_messages_in_arrival_order():
+            for message in await account.get_next_messages():
                 snapshot = await message.get_snapshot()
-                if not snapshot.is_bot and not snapshot.is_info:
+                if snapshot.from_id != SpecialContactId.SELF and not snapshot.is_bot and not snapshot.is_info:
                     await snapshot.chat.send_text(snapshot.text)
                 await snapshot.message.mark_seen()
 

deltachat-rpc-client/pyproject.toml

@@ -21,6 +21,9 @@ deltachat_rpc_client = [
 [project.entry-points.pytest11]
 "deltachat_rpc_client.pytestplugin" = "deltachat_rpc_client.pytestplugin"
 
+[tool.setuptools_scm]
+root = ".."
+
 [tool.black]
 line-length = 120
 

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
+from .const import EventType, SpecialContactId
 from .contact import Contact
 from .deltachat import DeltaChat
 from .message import Message
@@ -19,6 +19,7 @@ __all__ = [
     "DeltaChat",
     "EventType",
     "Message",
+    "SpecialContactId",
     "Rpc",
     "run_bot_cli",
     "run_client_cli",

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

@@ -1,5 +1,6 @@
 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
@@ -239,7 +240,22 @@ 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,6 +105,10 @@ 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,
@@ -126,7 +130,7 @@ class Chat:
             "file": file,
             "location": location,
             "overrideSenderName": override_sender_name,
-            "quotedMsg": quoted_msg,
+            "quotedMessageId": quoted_msg,
         }
         msg_id = await self._rpc.send_msg(self.account.id, self.id, draft)
         return Message(self.account, msg_id)

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, SystemMessageType
+from .const import COMMAND_PREFIX, EventType, SpecialContactId, SystemMessageType
 from .events import (
     EventFilter,
     GroupImageChanged,
@@ -189,9 +189,10 @@ class Client:
 
     async def _process_messages(self) -> None:
         if self._should_process_messages:
-            for message in await self.account.get_fresh_messages_in_arrival_order():
+            for message in await self.account.get_next_messages():
                 snapshot = await message.get_snapshot()
-                await self._on_new_msg(snapshot)
+                if snapshot.from_id not in [SpecialContactId.SELF, SpecialContactId.DEVICE]:
+                    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/const.py

@@ -31,6 +31,7 @@ class EventType(str, Enum):
     SMTP_MESSAGE_SENT = "SmtpMessageSent"
     IMAP_MESSAGE_DELETED = "ImapMessageDeleted"
     IMAP_MESSAGE_MOVED = "ImapMessageMoved"
+    IMAP_INBOX_IDLE = "ImapInboxIdle"
     NEW_BLOB_FILE = "NewBlobFile"
     DELETED_BLOB_FILE = "DeletedBlobFile"
     WARNING = "Warning"

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

@@ -55,6 +55,11 @@ class ACFactory:
     async def get_online_account(self) -> Account:
         account = await self.new_configured_account()
         await account.start_io()
+        while True:
+            event = await account.wait_for_event()
+            print(event)
+            if event.type == EventType.IMAP_INBOX_IDLE:
+                break
         return account
 
     async def get_online_accounts(self, num: int) -> List[Account]:

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()
-    await alice.get_fresh_messages()
-    await alice.get_fresh_messages_in_arrival_order()
+    assert await alice.get_fresh_messages()
+    assert await alice.get_next_messages()
 
     group = await alice.create_group("test group")
     await group.add_contact(alice_contact_bob)
@@ -147,7 +147,9 @@ 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()
@@ -303,3 +305,29 @@ 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-client/tox.ini

@@ -15,6 +15,7 @@ passenv =
 deps =
     pytest
     pytest-asyncio
+    pytest-timeout
     aiohttp
     aiodns
 
@@ -27,3 +28,6 @@ deps =
 commands =
     black --quiet --check --diff src/ examples/ tests/
     ruff src/ examples/ tests/
+
+[pytest]
+timeout = 60

deltachat-rpc-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.111.0"
+version = "1.113.0"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -9,19 +9,18 @@ license = "MPL-2.0"
 keywords = ["deltachat", "chat", "openpgp", "email", "encryption"]
 categories = ["cryptography", "std", "email"]
 
-[[bin]]
-name = "deltachat-rpc-server"
-
 [dependencies]
 deltachat-jsonrpc = { path = "../deltachat-jsonrpc", default-features = false }
+deltachat = { path = "..", default-features = false }
 
 anyhow = "1"
 env_logger = { version = "0.10.0" }
 futures-lite = "1.12.0"
 log = "0.4"
-serde_json = "1.0.91"
+serde_json = "1.0.95"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.25.0", features = ["io-std"] }
+tokio = { version = "1.27.0", features = ["io-std"] }
+tokio-util = "0.7.7"
 yerpc = { version = "0.4.0", features = ["anyhow_expose"] }
 
 [features]

deltachat-rpc-server/src/bin/deltachat-rpc-server/main.rs

@@ -1,71 +0,0 @@
-///! Delta Chat core RPC server.
-///!
-///! It speaks JSON Lines over stdio.
-use std::path::PathBuf;
-
-use anyhow::Result;
-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};
-use tokio::task::JoinHandle;
-use yerpc::{RpcClient, RpcSession};
-
-#[tokio::main(flavor = "multi_thread")]
-async fn main() -> Result<()> {
-    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 state = CommandApi::new(accounts);
-
-    let (client, mut out_receiver) = RpcClient::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 send_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        while let Some(message) = out_receiver.next().await {
-            let message = serde_json::to_string(&message)?;
-            log::trace!("RPC send {}", message);
-            println!("{message}");
-        }
-        Ok(())
-    });
-
-    // Receiver task reads JSON requests from stdin.
-    let recv_task: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
-        let stdin = io::stdin();
-        let mut lines = BufReader::new(stdin).lines();
-        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(())
-    });
-
-    // Wait for the end of stdin.
-    recv_task.await??;
-
-    // Shutdown the server.
-    send_task.abort();
-    events_task.abort();
-
-    Ok(())
-}

deltachat-rpc-server/src/main.rs

@@ -0,0 +1,163 @@
+use std::env;
+///! Delta Chat core RPC server.
+///!
+///! 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<()> {
+    let mut args = env::args_os();
+    let _program_name = args.next().context("no command line arguments found")?;
+    if let Some(first_arg) = args.next() {
+        if first_arg.to_str() == Some("--version") {
+            if let Some(arg) = args.next() {
+                return Err(anyhow!("Unrecognized argument {:?}", arg));
+            }
+            eprintln!("{}", &*DC_VERSION_STR);
+            return Ok(());
+        } else {
+            return Err(anyhow!("Unrecognized option {:?}", first_arg));
+        }
+    }
+    if let Some(arg) = args.next() {
+        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 (client, mut out_receiver) = RpcClient::new();
+    let session = RpcSession::new(client.clone(), state.clone());
+    let main_cancel = CancellationToken::new();
+
+    // Events task converts core events to JSON-RPC notifications.
+    let cancel = main_cancel.clone();
+    let events_task: JoinHandle<Result<()>> = tokio::spawn(async move {
+        let _cancel_guard = cancel.clone().drop_guard();
+        let mut r = Ok(());
+        while let Some(event) = events.recv().await {
+            if r.is_err() {
+                continue;
+            }
+            let event = event_to_json_rpc_notification(event);
+            r = 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)?,
+                }
+            };
+            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,
+                }
+            };
+            log::trace!("RPC recv {}", message);
+            let session = session.clone();
+            tokio::spawn(async move {
+                session.handle_incoming(&message).await;
+            });
+        }
+        Ok(())
+    });
+
+    // See "Thread safety" section in deltachat-ffi/deltachat.h for explanation.
+    // NB: Events are drained by events_task.
+    main_cancel.cancelled().await;
+    accounts.read().await.stop_io().await;
+    drop(accounts);
+    drop(state);
+    let (r0, r1, r2, r3) = tokio::join!(events_task, send_task, sigterm_task, recv_task);
+    for r in [r0, r1, r2, r3] {
+        r??;
+    }
+
+    Ok(())
+}

deltachat_derive/Cargo.toml

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

deny.toml

@@ -11,42 +11,50 @@ ignore = [
 # Accept some duplicate versions, ideally we work towards this list
 # becoming empty.  Adding versions forces us to revisit this at least
 # 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 = "darling", version = "<0.14" },
+     { name = "clap_lex", version = "0.2.4" },
+     { name = "clap", version = "3.2.23" },
+     { name = "convert_case", version = "0.4.0" },
+     { name = "curve25519-dalek", version = "3.2.0" },
      { 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 = "nom", version = "<7.1" },
+     { name = "libm", version = "0.1.4" },
+     { name = "pem-rfc7468", version = "0.6.0" },
+     { name = "pkcs8", version = "0.9.0" },
      { 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 = "time", version = "<0.3" },
-     { name = "version_check", version = "<0.9" },
-     { name = "wasi", version = "<0.11" },
-     { name = "windows-sys", version = "<0.45" },
-     { name = "windows_x86_64_msvc", version = "<0.42" },
-     { name = "windows_x86_64_gnu", version = "<0.42" },
-     { name = "windows_i686_msvc", version = "<0.42" },
-     { name = "windows_i686_gnu", version = "<0.42" },
-     { name = "windows_aarch64_msvc", version = "<0.42" },
-     { name = "unicode-xid", version = "<0.2.4" },
-     { name = "syn", version = "<1.0" },
-     { name = "quote", version = "<1.0" },
-     { name = "proc-macro2", version = "<1.0" },
-     { name = "portable-atomic", version = "<1.0" },
+     { name = "signature", version = "1.6.4" },
      { name = "spin", version = "<0.9.6" },
-     { name = "convert_case", version = "0.4.0" },
-     { name = "clap_lex", version = "0.2.4" },
-     { name = "clap", version = "3.2.23" },
+     { name = "spki", version = "0.6.0" },
+     { name = "syn", version = "1.0.109" },
+     { name = "time", version = "<0.3" },
+     { name = "wasi", version = "<0.11" },
+     { 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" },
 ]
 
 
@@ -78,7 +86,5 @@ license-files = [
 github = [
        "async-email",
        "deltachat",
-       "n0-computer",
        "quinn-rs",
-       "dignifiedquire",
 ]

node/constants.js

@@ -37,6 +37,7 @@ module.exports = {
   DC_EVENT_ERROR: 400,
   DC_EVENT_ERROR_SELF_NOT_IN_GROUP: 410,
   DC_EVENT_IMAP_CONNECTED: 102,
+  DC_EVENT_IMAP_INBOX_IDLE: 106,
   DC_EVENT_IMAP_MESSAGE_DELETED: 104,
   DC_EVENT_IMAP_MESSAGE_MOVED: 105,
   DC_EVENT_IMEX_FILE_WRITTEN: 2052,
@@ -112,6 +113,7 @@ module.exports = {
   DC_QR_ADDR: 320,
   DC_QR_ASK_VERIFYCONTACT: 200,
   DC_QR_ASK_VERIFYGROUP: 202,
+  DC_QR_BACKUP: 251,
   DC_QR_ERROR: 400,
   DC_QR_FPR_MISMATCH: 220,
   DC_QR_FPR_OK: 210,
@@ -149,6 +151,8 @@ 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,
   DC_STR_CANNOT_LOGIN: 60,

node/events.js

@@ -8,6 +8,7 @@ module.exports = {
   103: 'DC_EVENT_SMTP_MESSAGE_SENT',
   104: 'DC_EVENT_IMAP_MESSAGE_DELETED',
   105: 'DC_EVENT_IMAP_MESSAGE_MOVED',
+  106: 'DC_EVENT_IMAP_INBOX_IDLE',
   150: 'DC_EVENT_NEW_BLOB_FILE',
   151: 'DC_EVENT_DELETED_BLOB_FILE',
   300: 'DC_EVENT_WARNING',

node/lib/constants.ts

@@ -37,6 +37,7 @@ export enum C {
   DC_EVENT_ERROR = 400,
   DC_EVENT_ERROR_SELF_NOT_IN_GROUP = 410,
   DC_EVENT_IMAP_CONNECTED = 102,
+  DC_EVENT_IMAP_INBOX_IDLE = 106,
   DC_EVENT_IMAP_MESSAGE_DELETED = 104,
   DC_EVENT_IMAP_MESSAGE_MOVED = 105,
   DC_EVENT_IMEX_FILE_WRITTEN = 2052,
@@ -112,6 +113,7 @@ export enum C {
   DC_QR_ADDR = 320,
   DC_QR_ASK_VERIFYCONTACT = 200,
   DC_QR_ASK_VERIFYGROUP = 202,
+  DC_QR_BACKUP = 251,
   DC_QR_ERROR = 400,
   DC_QR_FPR_MISMATCH = 220,
   DC_QR_FPR_OK = 210,
@@ -149,6 +151,8 @@ 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,
   DC_STR_CANNOT_LOGIN = 60,
@@ -289,6 +293,7 @@ export const EventId2EventName: { [key: number]: string } = {
   103: 'DC_EVENT_SMTP_MESSAGE_SENT',
   104: 'DC_EVENT_IMAP_MESSAGE_DELETED',
   105: 'DC_EVENT_IMAP_MESSAGE_MOVED',
+  106: 'DC_EVENT_IMAP_INBOX_IDLE',
   150: 'DC_EVENT_NEW_BLOB_FILE',
   151: 'DC_EVENT_DELETED_BLOB_FILE',
   300: 'DC_EVENT_WARNING',

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.111.0"
-}
+  "version": "1.113.0"
+}

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 try to install the ``deltachat`` binary "wheel" packages
+If you have a Linux system you may 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 `install virtualenv <https://virtualenv.pypa.io/en/stable/installation.html>`_,
-then create a fresh Python virtual environment and activate it in your shell::
+We recommend to first create a fresh Python virtual environment
+and activate it in your shell::
 
-        virtualenv env  # or: python -m venv
-        source env/bin/activate
+    python -m venv env
+    source env/bin/activate
 
 Afterwards, invoking ``python`` or ``pip install`` only
 modifies files in your ``env`` directory and leaves
@@ -40,16 +40,14 @@ To verify it worked::
 Running tests
 =============
 
-Recommended way to run tests is using `tox <https://tox.wiki>`_.
-After successful binding installation you can install tox
-and run the tests::
+Recommended way to run tests is using `scripts/run-python-test.sh`
+script provided in the core repository.
 
-    pip install tox
-    tox -e py3
-
-This will run all "offline" tests and skip all functional
+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
 end-to-end tests that require accounts on real e-mail servers.
 
+.. _`tox`: https://tox.wiki
 .. _livetests:
 
 Running "live" tests with temporary accounts
@@ -61,13 +59,32 @@ 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 exists only for one hour and then are removed completely.
-One hour is enough to invoke pytest and run all offline and online tests::
+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::
 
-    tox -e py3
+    tox -e py
 
 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
@@ -89,20 +106,34 @@ 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.
 
-Ensure you are in the deltachat-core-rust/python directory, create the
-virtual environment with dependencies using tox
-and activate it in your shell::
+First, build the core library::
 
-   cd python
-   tox --devenv env
+   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
    source env/bin/activate
 
-You should now be able to build the python bindings using the supplied script::
+Build and install the bindings:
 
-   python3 install_python_bindings.py
+   export DCC_RS_DEV="$PWD"
+   export DCC_RS_TARGET=release
+   python -m pip install ./python
 
-The core compilation and bindings building might take a while,
-depending on the speed of your machine.
+`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.
 
 Building manylinux based wheels
 ===============================

python/examples/test_examples.py

@@ -24,6 +24,8 @@ 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()
@@ -40,7 +42,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, ffi=False)
+    botproc = acfactory.run_bot_process(group_tracking)
 
     ac1, ac2 = acfactory.get_online_accounts(2)
 
@@ -52,6 +54,8 @@ 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

@@ -1,30 +0,0 @@
-#!/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,6 +376,22 @@ 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/events.py

@@ -190,7 +190,7 @@ class FFIEventTracker:
         - ac2 is still running FetchExsistingMsgs job and thinks it's an existing, old message
         - therefore no DC_EVENT_INCOMING_MSG is sent
         """
-        self.get_info_contains("INBOX: Idle entering")
+        self.get_matching("DC_EVENT_IMAP_INBOX_IDLE")
 
     def wait_next_incoming_message(self):
         """wait for and return next incoming message."""

python/src/deltachat/message.py

@@ -344,6 +344,16 @@ 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,6 +676,13 @@ 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/auditwheels.py

@@ -1,19 +0,0 @@
-import os
-import subprocess
-import sys
-
-if __name__ == "__main__":
-    assert len(sys.argv) == 2
-    workspacedir = sys.argv[1]
-    for relpath in os.listdir(workspacedir):
-        if relpath.startswith("deltachat"):
-            p = os.path.join(workspacedir, relpath)
-            subprocess.check_call(
-                [
-                    "auditwheel",
-                    "repair",
-                    p,
-                    "-w",
-                    workspacedir,
-                ],
-            )

python/tests/test_0_complex_or_slow.py

@@ -220,16 +220,16 @@ def test_fetch_existing(acfactory, lp, mvbox_move):
     acfactory.bring_accounts_online()
     assert_folders_configured(ac1)
 
-    assert ac1.direct_imap.select_config_folder("mvbox" if mvbox_move else "inbox")
-    with ac1.direct_imap.idle() as idle1:
-        lp.sec("send out message with bcc to ourselves")
-        ac1.set_config("bcc_self", "1")
-        chat = acfactory.get_accepted_chat(ac1, ac2)
-        chat.send_text("message text")
-        assert_folders_configured(ac1)
+    lp.sec("send out message with bcc to ourselves")
+    ac1.set_config("bcc_self", "1")
+    chat = acfactory.get_accepted_chat(ac1, ac2)
+    chat.send_text("message text")
 
-        lp.sec("wait until the bcc_self message arrives in correct folder and is marked seen")
-        assert idle1.wait_for_seen()
+    lp.sec("wait until the bcc_self message arrives in correct folder and is marked seen")
+    if mvbox_move:
+        ac1._evtracker.get_info_contains("Marked messages [0-9]+ in folder DeltaChat as seen.")
+    else:
+        ac1._evtracker.get_info_contains("Marked messages [0-9]+ in folder INBOX as seen.")
     assert_folders_configured(ac1)
 
     lp.sec("create a cloned ac1 and fetch contact history during configure")
@@ -271,12 +271,12 @@ def test_fetch_existing_msgs_group_and_single(acfactory, lp):
     ac1._evtracker.wait_next_incoming_message()
 
     lp.sec("send out message with bcc to ourselves")
-    with ac1.direct_imap.idle() as idle1:
-        ac1.set_config("bcc_self", "1")
-        ac1_ac2_chat = ac1.create_chat(ac2)
-        ac1_ac2_chat.send_text("outgoing, encrypted direct message, creating a chat")
-        # wait until the bcc_self message arrives
-        assert idle1.wait_for_seen()
+    ac1.set_config("bcc_self", "1")
+    ac1_ac2_chat = ac1.create_chat(ac2)
+    ac1_ac2_chat.send_text("outgoing, encrypted direct message, creating a chat")
+
+    # wait until the bcc_self message arrives
+    ac1._evtracker.get_info_contains("Marked messages [0-9]+ in folder INBOX as seen.")
 
     lp.sec("Clone online account and let it fetch the existing messages")
     ac1_clone = acfactory.new_online_configuring_account(cloned_from=ac1)

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._evtracker.wait_next_incoming_message()
+    msg_in = ac2.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._evtracker.wait_next_incoming_message()
+    msg2_in = ac1.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._evtracker.wait_next_incoming_message()
+    msg3_in = ac2.wait_next_incoming_message()
     assert msg3_in.text == "message3"
     assert msg3_in.is_encrypted()
 
@@ -134,22 +134,27 @@ def test_one_account_send_bcc_setting(acfactory, lp):
     ac1.set_config("bcc_self", "1")
 
     lp.sec("send out message with bcc to ourselves")
-    with ac1.direct_imap.idle() as idle1:
-        msg_out = chat.send_text("message2")
+    msg_out = chat.send_text("message2")
 
-        # wait for send out (BCC)
-        ev = ac1._evtracker.get_matching("DC_EVENT_SMTP_MESSAGE_SENT")
-        assert ac1.get_config("bcc_self") == "1"
+    # wait for send out (BCC)
+    ev = ac1._evtracker.get_matching("DC_EVENT_SMTP_MESSAGE_SENT")
+    assert ac1.get_config("bcc_self") == "1"
 
-        # now make sure we are sending message to ourselves too
-        assert self_addr in ev.data2
-        assert other_addr in ev.data2
-        assert idle1.wait_for_seen()
-
-    # Second client receives only second message, but not the first
+    # Second client receives only second message, but not the first.
     ev_msg = ac1_clone._evtracker.wait_next_messages_changed()
     assert ev_msg.text == msg_out.text
 
+    # now make sure we are sending message to ourselves too
+    assert self_addr in ev.data2
+    assert other_addr in ev.data2
+
+    # BCC-self messages are marked as seen by the sender device.
+    ac1._evtracker.get_info_contains("Marked messages [0-9]+ in folder INBOX as seen.")
+
+    # Check that the message is marked as seen on IMAP.
+    ac1.direct_imap.select_folder("Inbox")
+    assert len(list(ac1.direct_imap.conn.fetch(AND(seen=True)))) == 1
+
 
 def test_send_file_twice_unicode_filename_mangling(tmpdir, acfactory, lp):
     ac1, ac2 = acfactory.get_online_accounts(2)
@@ -314,6 +319,9 @@ def test_webxdc_message(acfactory, data, lp):
     assert msg2.text == "message1"
     assert msg2.is_webxdc()
     assert msg2.filename
+    ac2._evtracker.get_info_contains("Marked messages [0-9]+ in folder INBOX as seen.")
+    ac2.direct_imap.select_folder("Inbox")
+    assert len(list(ac2.direct_imap.conn.fetch(AND(seen=True)))) == 1
 
 
 def test_mvbox_sentbox_threads(acfactory, lp):
@@ -513,22 +521,22 @@ def test_send_and_receive_message_markseen(acfactory, lp):
     msg4 = ac2._evtracker.wait_next_incoming_message()
 
     lp.sec("mark messages as seen on ac2, wait for changes on ac1")
-    with ac1.direct_imap.idle() as idle1:
-        with ac2.direct_imap.idle() as idle2:
-            ac2.mark_seen_messages([msg2, msg4])
-            ev = ac2._evtracker.get_matching("DC_EVENT_MSGS_NOTICED")
-            assert msg2.chat.id == msg4.chat.id
-            assert ev.data1 == msg2.chat.id
-            assert ev.data2 == 0
-            idle2.wait_for_seen()
+    ac2.mark_seen_messages([msg2, msg4])
+    ev = ac2._evtracker.get_matching("DC_EVENT_MSGS_NOTICED")
+    assert msg2.chat.id == msg4.chat.id
+    assert ev.data1 == msg2.chat.id
+    assert ev.data2 == 0
+    ac2._evtracker.get_info_contains("Marked messages .* in folder INBOX as seen.")
 
-        lp.step("1")
-        for _i in range(2):
-            ev = ac1._evtracker.get_matching("DC_EVENT_MSG_READ")
-            assert ev.data1 > const.DC_CHAT_ID_LAST_SPECIAL
-            assert ev.data2 > const.DC_MSG_ID_LAST_SPECIAL
-        lp.step("2")
-        idle1.wait_for_seen()  # Check that ac1 marks the read receipt as read
+    lp.step("1")
+    for _i in range(2):
+        ev = ac1._evtracker.get_matching("DC_EVENT_MSG_READ")
+        assert ev.data1 > const.DC_CHAT_ID_LAST_SPECIAL
+        assert ev.data2 > const.DC_MSG_ID_LAST_SPECIAL
+    lp.step("2")
+
+    # Check that ac1 marks the read receipt as read.
+    ac1._evtracker.get_info_contains("Marked messages .* in folder INBOX as seen.")
 
     assert msg1.is_out_mdn_received()
     assert msg3.is_out_mdn_received()
@@ -559,7 +567,8 @@ def test_moved_markseen(acfactory):
 
     with ac2.direct_imap.idle() as idle2:
         ac2.start_io()
-        msg = ac2._evtracker.wait_next_incoming_message()
+        ev = ac2._evtracker.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
+        msg = ac2.get_message_by_id(ev.data2)
 
         # Accept the contact request.
         msg.chat.accept()
@@ -613,18 +622,24 @@ def test_markseen_message_and_mdn(acfactory, mvbox_move):
     # Do not send BCC to self, we only want to test MDN on ac1.
     ac1.set_config("bcc_self", "0")
 
+    acfactory.get_accepted_chat(ac1, ac2).send_text("hi")
+    msg = ac2._evtracker.wait_next_incoming_message()
+
+    ac2.mark_seen_messages([msg])
+
     folder = "mvbox" if mvbox_move else "inbox"
+    for ac in [ac1, ac2]:
+        if mvbox_move:
+            ac._evtracker.get_info_contains("Marked messages [0-9]+ in folder DeltaChat as seen.")
+        else:
+            ac._evtracker.get_info_contains("Marked messages [0-9]+ in folder INBOX as seen.")
     ac1.direct_imap.select_config_folder(folder)
     ac2.direct_imap.select_config_folder(folder)
-    with ac1.direct_imap.idle() as idle1:
-        with ac2.direct_imap.idle() as idle2:
-            acfactory.get_accepted_chat(ac1, ac2).send_text("hi")
-            msg = ac2._evtracker.wait_next_incoming_message()
 
-            ac2.mark_seen_messages([msg])
-
-            idle2.wait_for_seen()  # Check original message is marked as seen
-            idle1.wait_for_seen()  # Check that the mdn is marked as seen
+    # Check that the mdn is marked as seen
+    assert len(list(ac1.direct_imap.conn.fetch(AND(seen=True)))) == 1
+    # Check original message is marked as seen
+    assert len(list(ac2.direct_imap.conn.fetch(AND(seen=True)))) == 1
 
 
 def test_reply_privately(acfactory):
@@ -678,23 +693,24 @@ def test_mdn_asymmetric(acfactory, lp):
 
     assert len(msg.chat.get_messages()) == 1
 
-    ac1.direct_imap.select_config_folder("mvbox")
-    with ac1.direct_imap.idle() as idle1:
-        lp.sec("ac2: mark incoming message as seen")
-        ac2.mark_seen_messages([msg])
+    lp.sec("ac2: mark incoming message as seen")
+    ac2.mark_seen_messages([msg])
 
-        lp.sec("ac1: waiting for incoming activity")
-        # MDN should be moved even though MDNs are already disabled
-        ac1._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_MOVED")
+    lp.sec("ac1: waiting for incoming activity")
+    # MDN should be moved even though MDNs are already disabled
+    ac1._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_MOVED")
 
-        assert len(chat.get_messages()) == 1
+    assert len(chat.get_messages()) == 1
 
-        # Wait for the message to be marked as seen on IMAP.
-        assert idle1.wait_for_seen()
+    # Wait for the message to be marked as seen on IMAP.
+    ac1._evtracker.get_info_contains("Marked messages 1 in folder DeltaChat as seen.")
 
     # MDN is received even though MDNs are already disabled
     assert msg_out.is_out_mdn_received()
 
+    ac1.direct_imap.select_config_folder("mvbox")
+    assert len(list(ac1.direct_imap.conn.fetch(AND(seen=True)))) == 1
+
 
 def test_send_and_receive_will_encrypt_decrypt(acfactory, lp):
     ac1, ac2 = acfactory.get_online_accounts(2)

python/tox.ini

@@ -33,18 +33,6 @@ passenv =
     CARGO_TARGET_DIR
     RUSTC_WRAPPER
 
-[testenv:auditwheels]
-skipsdist = True
-deps = auditwheel
-passenv =
-    DCC_RS_DEV
-    DCC_RS_TARGET
-    AUDITWHEEL_ARCH
-    AUDITWHEEL_PLAT
-    AUDITWHEEL_POLICY
-commands = 
-    python tests/auditwheels.py {toxworkdir}/wheelhouse
-
 [testenv:lint]
 skipsdist = True
 skip_install = True
@@ -55,7 +43,7 @@ deps =
     pygments
     restructuredtext_lint 
 commands =
-    black --quiet --check --diff setup.py install_python_bindings.py src/deltachat examples/ tests/
+    black --quiet --check --diff setup.py src/deltachat examples/ tests/
     ruff src/deltachat tests/ examples/
     rst-lint --encoding 'utf-8' README.rst
 

release-date.in

@@ -0,0 +1 @@
+2023-04-18

scripts/README.md

@@ -8,6 +8,8 @@ and an own build machine.
 
 - `clippy.sh` runs `cargo clippy` for all Rust code in the project.
 
+- `deny.sh` runs `cargo deny` for all Rust code in the project.
+
 - `../.github/workflows` contains jobs run by GitHub Actions.
 
 - `remote_tests_python.sh` rsyncs to a build machine and runs

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/deny.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+cargo deny --workspace --all-features check -D warnings

scripts/run-python-test.sh

@@ -12,7 +12,7 @@ export DCC_RS_DEV=`pwd`
 
 cd python
 
-python install_python_bindings.py onlybuild
+cargo build -p deltachat_ffi --features jsonrpc
 
 # remove and inhibit writing PYC files 
 rm -rf tests/__pycache__
@@ -22,4 +22,5 @@ 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,py3
+tox -e doc
+tox -e py -- "$@"

scripts/run_all.sh

@@ -31,7 +31,9 @@ unset DCC_NEW_TMP_EMAIL
 
 # Try to build wheels for a range of interpreters, but don't fail if they are not available.
 # E.g. musllinux_1_1 does not have PyPy interpreters as of 2022-07-10
-tox --workdir "$TOXWORKDIR" -e py37,py38,py39,py310,py311,pypy37,pypy38,pypy39,auditwheels --skip-missing-interpreters true
+tox --workdir "$TOXWORKDIR" -e py37,py38,py39,py310,py311,pypy37,pypy38,pypy39 --skip-missing-interpreters true
+
+auditwheel repair "$TOXWORKDIR"/wheelhouse/deltachat* -w "$TOXWORKDIR/wheelhouse"
 
 
 echo -----------------------

scripts/set_core_version.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+import datetime
 import json
 import os
 import pathlib
@@ -56,7 +57,8 @@ def update_package_json(relpath, newversion):
         json_data = json.loads(f.read())
     json_data["version"] = newversion
     with open(p, "w") as f:
-        f.write(json.dumps(json_data, sort_keys=True, indent=2))
+        json.dump(json_data, f, sort_keys=True, indent=2)
+        f.write("\n")
 
 
 def main():
@@ -90,15 +92,25 @@ def main():
     ffi_toml = read_toml_version("deltachat-ffi/Cargo.toml")
     assert core_toml == ffi_toml, (core_toml, ffi_toml)
 
+    today = datetime.date.today().isoformat()
+
     if "alpha" not in newversion:
-        for line in open("CHANGELOG.md"):
+        changelog_name = "CHANGELOG.md"
+        changelog_tmpname = changelog_name + ".tmp"
+        changelog_tmp = open(changelog_tmpname, "w")
+        found = False
+        for line in open(changelog_name):
             ## 1.25.0
-            if line.startswith("## ") and line[2:].strip().startswith(newversion):
-                break
-        else:
+            if line == f"## [{newversion}]\n":
+                line = f"## [{newversion}] - {today}\n"
+                found = True
+            changelog_tmp.write(line)
+        if not found:
             raise SystemExit(
-                f"CHANGELOG.md contains no entry for version: {newversion}"
+                f"{changelog_name} contains no entry for version: {newversion}"
             )
+        changelog_tmp.close()
+        os.rename(changelog_tmpname, changelog_name)
 
     for toml_filename in toml_list:
         replace_toml_version(toml_filename, newversion)
@@ -106,6 +118,9 @@ def main():
     for json_filename in json_list:
         update_package_json(json_filename, newversion)
 
+    with open("release-date.in", "w") as f:
+        f.write(today)
+
     print("running cargo check")
     subprocess.call(["cargo", "check"])
 

scripts/zig-cc

@@ -0,0 +1,32 @@
+#!/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,12 +1,15 @@
 #!/bin/sh
 #
-# Build statically linked deltachat-rpc-server using cargo-zigbuild.
+# Build statically linked deltachat-rpc-server using zig.
 
 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
@@ -15,9 +18,35 @@ 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"
 
-cargo install cargo-zigbuild
+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
 
-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
+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

src/accounts.rs

@@ -6,6 +6,7 @@ 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;
@@ -17,6 +18,7 @@ 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.
@@ -77,12 +79,12 @@ impl Accounts {
         })
     }
 
-    /// Get an account by its `id`:
+    /// Returns an account by its `id`:
     pub fn get_account(&self, id: u32) -> Option<Context> {
         self.accounts.get(&id).cloned()
     }
 
-    /// Get the currently selected account.
+    /// Returns the currently selected account.
     pub fn get_selected_account(&self) -> Option<Context> {
         let id = self.config.get_selected_account();
         self.accounts.get(&id).cloned()
@@ -96,14 +98,14 @@ impl Accounts {
         }
     }
 
-    /// Select the given account.
+    /// Selects the given account.
     pub async fn select_account(&mut self, id: u32) -> Result<()> {
         self.config.select_account(id).await?;
 
         Ok(())
     }
 
-    /// Add a new account and opens it.
+    /// Adds a new account and opens it.
     ///
     /// Returns account ID.
     pub async fn add_account(&mut self) -> Result<u32> {
@@ -138,7 +140,7 @@ impl Accounts {
         Ok(account_config.id)
     }
 
-    /// Remove an account.
+    /// Removes an account.
     pub async fn remove_account(&mut self, id: u32) -> Result<()> {
         let ctx = self
             .accounts
@@ -159,7 +161,7 @@ impl Accounts {
         Ok(())
     }
 
-    /// Migrate an existing account into this structure.
+    /// Migrates an existing account into this structure.
     ///
     /// Returns the ID of new account.
     pub async fn migrate_account(&mut self, dbfile: PathBuf) -> Result<u32> {
@@ -262,7 +264,7 @@ impl Accounts {
     pub async fn stop_io(&self) {
         // Sending an event here wakes up event loop even
         // if there are no accounts.
-        info!(self, "Stopping IO for all accounts");
+        info!(self, "Stopping IO for all accounts.");
         for account in self.accounts.values() {
             account.stop_io().await;
         }
@@ -301,7 +303,7 @@ pub const DB_NAME: &str = "dc.db";
 
 /// Account manager configuration file.
 #[derive(Debug, Clone, PartialEq)]
-pub struct Config {
+struct Config {
     file: PathBuf,
     inner: InnerConfig,
 }
@@ -325,10 +327,8 @@ impl Config {
             selected_account: 0,
             next_id: 1,
         };
-        let cfg = Config {
-            file: dir.join(CONFIG_NAME),
-            inner,
-        };
+        let file = dir.join(CONFIG_NAME);
+        let mut cfg = Self { file, inner };
 
         cfg.sync().await?;
 
@@ -336,10 +336,24 @@ impl Config {
     }
 
     /// Sync the inmemory representation to disk.
-    async fn sync(&self) -> Result<()> {
-        fs::write(&self.file, toml::to_string_pretty(&self.inner)?)
+    /// 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)
             .await
-            .context("failed to write config")
+            .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(())
     }
 
     /// Read a configuration from the given file into memory.
@@ -359,7 +373,7 @@ impl Config {
             }
         }
 
-        let config = Self { file, inner };
+        let mut config = Self { file, inner };
         if modified {
             config.sync().await?;
         }
@@ -503,17 +517,19 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         let p: PathBuf = dir.path().join("accounts1");
 
-        let mut accounts1 = Accounts::new(p.clone()).await.unwrap();
-        accounts1.add_account().await.unwrap();
+        {
+            let mut accounts = Accounts::new(p.clone()).await.unwrap();
+            accounts.add_account().await.unwrap();
 
-        let accounts2 = Accounts::open(p).await.unwrap();
+            assert_eq!(accounts.accounts.len(), 1);
+            assert_eq!(accounts.config.get_selected_account(), 1);
+        }
+        {
+            let accounts = Accounts::open(p).await.unwrap();
 
-        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());
+            assert_eq!(accounts.accounts.len(), 1);
+            assert_eq!(accounts.config.get_selected_account(), 1);
+        }
     }
 
     #[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=?",
-            paramsv![from_domain],
+            (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",
-            paramsv![from_domain, timestamp],
+            (from_domain, timestamp),
         )
         .await?;
     Ok(())

src/blob.rs

@@ -9,21 +9,17 @@ use std::path::{Path, PathBuf};
 
 use anyhow::{format_err, Context as _, Result};
 use futures::StreamExt;
-use image::{DynamicImage, ImageFormat};
+use image::{DynamicImage, ImageFormat, ImageOutputFormat};
 use num_traits::FromPrimitive;
 use tokio::io::AsyncWriteExt;
 use tokio::{fs, io};
 use tokio_stream::wrappers::ReadDirStream;
 
 use crate::config::Config;
-use crate::constants::{
-    MediaQuality, BALANCED_AVATAR_SIZE, BALANCED_IMAGE_SIZE, WORSE_AVATAR_SIZE, WORSE_IMAGE_SIZE,
-};
+use crate::constants::{self, MediaQuality};
 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.
 ///
@@ -92,7 +88,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.ok_or_log(context);
+                        fs::create_dir_all(dir).await.log_err(context).ok();
                     } else {
                         name = format!("{}-{}{}", stem, rand::random::<u32>(), ext);
                     }
@@ -323,119 +319,149 @@ impl<'a> BlobObject<'a> {
             match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
                 .unwrap_or_default()
             {
-                MediaQuality::Balanced => BALANCED_AVATAR_SIZE,
-                MediaQuality::Worse => WORSE_AVATAR_SIZE,
+                MediaQuality::Balanced => constants::BALANCED_AVATAR_SIZE,
+                MediaQuality::Worse => constants::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, Some(20_000))? {
+        if let Some(new_name) =
+            self.recode_to_size(context, blob_abs, img_wh, 20_000, strict_limits)?
+        {
             self.name = new_name;
         }
         Ok(())
     }
 
-    pub async fn recode_to_image_size(&self, context: &Context) -> Result<()> {
+    pub async fn recode_to_image_size(&mut self, context: &Context) -> Result<()> {
         let blob_abs = self.to_abs_path();
-        if message::guess_msgtype_from_suffix(Path::new(&blob_abs))
-            != Some((Viewtype::Image, "image/jpeg"))
-        {
-            return Ok(());
-        }
-
-        let img_wh =
+        let (img_wh, max_bytes) =
             match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
                 .unwrap_or_default()
             {
-                MediaQuality::Balanced => BALANCED_IMAGE_SIZE,
-                MediaQuality::Worse => WORSE_IMAGE_SIZE,
+                MediaQuality::Balanced => (
+                    constants::BALANCED_IMAGE_SIZE,
+                    constants::BALANCED_IMAGE_BYTES,
+                ),
+                MediaQuality::Worse => (constants::WORSE_IMAGE_SIZE, constants::WORSE_IMAGE_BYTES),
             };
-
-        if self
-            .recode_to_size(context, blob_abs, img_wh, None)?
-            .is_some()
+        let strict_limits = false;
+        if let Some(new_name) =
+            self.recode_to_size(context, blob_abs, img_wh, max_bytes, strict_limits)?
         {
-            return Err(format_err!(
-                "Internal error: recode_to_size(..., None) shouldn't change the name of the image"
-            ));
+            self.name = new_name;
         }
         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: Option<usize>,
+        max_bytes: usize,
+        strict_limits: bool,
     ) -> Result<Option<String>> {
         tokio::task::block_in_place(move || {
-            let mut img = image::open(&blob_abs).context("image recode failure")?;
-            let orientation = self.get_exif_orientation(context);
+            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 encoded = Vec::new();
             let mut changed_name = None;
 
-            let exceeds_width = img.width() > img_wh || img.height() > img_wh;
+            img = match orientation {
+                Some(90) => img.rotate90(),
+                Some(180) => img.rotate180(),
+                Some(270) => img.rotate270(),
+                _ => img,
+            };
 
-            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 exceeds_wh = img.width() > img_wh || img.height() > img_wh;
+            let exceeds_max_bytes = nr_bytes > max_bytes as u64;
 
-            if do_scale || do_rotate {
-                if do_rotate {
-                    img = match orientation {
-                        Ok(90) => img.rotate90(),
-                        Ok(180) => img.rotate180(),
-                        Ok(270) => img.rotate270(),
-                        _ => img,
-                    }
+            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 {
-                    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!(
+            };
+            // 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(
                                 context,
-                                "Final scaled-down image size: {}B ({}px)",
-                                encoded.len(),
-                                img_wh
-                            );
-                            break;
-                        }
+                                &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;
                     }
                 }
 
-                // The file format is JPEG now, we may have to change the file extension
-                if !matches!(ImageFormat::from_path(&blob_abs), Ok(ImageFormat::Jpeg)) {
+                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,
+                            ));
+                        }
+
+                        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(_))
+                {
                     blob_abs = blob_abs.with_extension("jpg");
-                    let file_name = blob_abs.file_name().context("No avatar file name (???)")?;
+                    let file_name = blob_abs.file_name().context("No image 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, &mut encoded)?;
+                    encode_img(&img, ofmt, &mut encoded)?;
                 }
 
                 std::fs::write(&blob_abs, &encoded)
@@ -446,25 +472,30 @@ impl<'a> BlobObject<'a> {
         })
     }
 
-    pub fn get_exif_orientation(&self, context: &Context) -> Result<i32> {
+    /// Returns image file size and Exif.
+    pub fn metadata(&self) -> Result<(u64, Option<exif::Exif>)> {
         let file = std::fs::File::open(self.to_abs_path())?;
+        let len = file.metadata()?.len();
         let mut bufreader = std::io::BufReader::new(&file);
-        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)
+        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:?}."),
+        }
+    }
+    0
+}
+
 impl<'a> fmt::Display for BlobObject<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "$BLOBDIR/{}", self.name)
@@ -490,7 +521,7 @@ impl<'a> BlobDirContents<'a> {
                 match entry {
                     Ok(entry) => Some(entry),
                     Err(err) => {
-                        error!(context, "Failed to read blob file: {err}");
+                        error!(context, "Failed to read blob file: {err}.");
                         None
                     }
                 }
@@ -501,7 +532,7 @@ impl<'a> BlobDirContents<'a> {
                     false => {
                         warn!(
                             context,
-                            "Export: Found blob dir entry {} that is not a file, ignoring",
+                            "Export: Found blob dir entry {} that is not a file, ignoring.",
                             entry.path().display()
                         );
                         None
@@ -552,31 +583,35 @@ impl<'a> Iterator for BlobDirIter<'a> {
 
 impl FusedIterator for BlobDirIter<'_> {}
 
-fn encode_img(img: &DynamicImage, encoded: &mut Vec<u8>) -> anyhow::Result<()> {
+fn encode_img(
+    img: &DynamicImage,
+    fmt: ImageOutputFormat,
+    encoded: &mut Vec<u8>,
+) -> anyhow::Result<()> {
     encoded.clear();
     let mut buf = Cursor::new(encoded);
-    img.write_to(&mut buf, image::ImageFormat::Jpeg)?;
+    img.write_to(&mut buf, fmt)?;
     Ok(())
 }
+
 fn encoded_img_exceeds_bytes(
     context: &Context,
     img: &DynamicImage,
-    max_bytes: Option<usize>,
+    fmt: ImageOutputFormat,
+    max_bytes: usize,
     encoded: &mut Vec<u8>,
 ) -> anyhow::Result<bool> {
-    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);
-        }
+    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);
     }
     Ok(false)
 }
@@ -589,7 +624,7 @@ mod tests {
 
     use super::*;
     use crate::chat::{self, create_group_chat, ProtectionStatus};
-    use crate::message::Message;
+    use crate::message::{Message, Viewtype};
     use crate::test_utils::{self, TestContext};
 
     fn check_image_size(path: impl AsRef<Path>, width: u32, height: u32) -> image::DynamicImage {
@@ -814,7 +849,11 @@ 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, BALANCED_AVATAR_SIZE, BALANCED_AVATAR_SIZE);
+        check_image_size(
+            &avatar_blob,
+            constants::BALANCED_AVATAR_SIZE,
+            constants::BALANCED_AVATAR_SIZE,
+        );
 
         async fn file_size(path_buf: &Path) -> u64 {
             let file = File::open(path_buf).await.unwrap();
@@ -822,8 +861,8 @@ mod tests {
         }
 
         let blob = BlobObject::new_from_path(&t, &avatar_blob).await.unwrap();
-
-        blob.recode_to_size(&t, blob.to_abs_path(), 1000, Some(3000))
+        let strict_limits = true;
+        blob.recode_to_size(&t, blob.to_abs_path(), 1000, 3000, strict_limits)
             .unwrap();
         assert!(file_size(&avatar_blob).await <= 3000);
         assert!(file_size(&avatar_blob).await > 2000);
@@ -850,10 +889,14 @@ mod tests {
         let avatar_cfg = t.get_config(Config::Selfavatar).await.unwrap().unwrap();
         assert_eq!(
             avatar_cfg,
-            avatar_src.with_extension("jpg").to_str().unwrap()
+            avatar_src.with_extension("png").to_str().unwrap()
         );
 
-        check_image_size(avatar_cfg, BALANCED_AVATAR_SIZE, BALANCED_AVATAR_SIZE);
+        check_image_size(
+            avatar_cfg,
+            constants::BALANCED_AVATAR_SIZE,
+            constants::BALANCED_AVATAR_SIZE,
+        );
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -879,18 +922,29 @@ 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");
-        // 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"),
+            Some("0"),
             bytes,
+            "jpg",
+            true, // has Exif
             1000,
             1000,
             0,
-            WORSE_IMAGE_SIZE,
-            WORSE_IMAGE_SIZE,
+            1000,
+            1000,
+        )
+        .await
+        .unwrap();
+        send_image_check_mediaquality(
+            Some("1"),
+            bytes,
+            "jpg",
+            true, // has Exif
+            1000,
+            1000,
+            0,
+            1000,
+            1000,
         )
         .await
         .unwrap();
@@ -903,69 +957,87 @@ mod tests {
         let img_rotated = send_image_check_mediaquality(
             Some("0"),
             bytes,
+            "jpg",
+            true, // has Exif
             2000,
             1800,
             270,
-            BALANCED_IMAGE_SIZE * 1800 / 2000,
-            BALANCED_IMAGE_SIZE,
+            1800,
+            2000,
         )
         .await
         .unwrap();
         assert_correct_rotation(&img_rotated);
 
         let mut buf = Cursor::new(vec![]);
-        img_rotated
-            .write_to(&mut buf, image::ImageFormat::Jpeg)
-            .unwrap();
+        img_rotated.write_to(&mut buf, 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,
-            BALANCED_IMAGE_SIZE * 1800 / 2000,
-            BALANCED_IMAGE_SIZE,
+            "jpg",
+            false, // no Exif
+            1800,
+            2000,
             0,
-            WORSE_IMAGE_SIZE * 1800 / 2000,
-            WORSE_IMAGE_SIZE,
+            1800,
+            2000,
         )
         .await
         .unwrap();
         assert_correct_rotation(&img_rotated);
-
-        join_handle.await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    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);
+    async fn test_recode_image_balanced_png() {
+        let bytes = include_bytes!("../test-data/image/screenshot.png");
 
-        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);
+        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();
     }
 
     fn assert_correct_rotation(img: &DynamicImage) {
@@ -985,9 +1057,12 @@ 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,
@@ -999,7 +1074,7 @@ mod tests {
         alice
             .set_config(Config::MediaQuality, media_quality_config)
             .await?;
-        let file = alice.get_blobdir().join("file.jpg");
+        let file = alice.get_blobdir().join("file").with_extension(extension);
 
         fs::write(&file, &bytes)
             .await
@@ -1007,7 +1082,13 @@ mod tests {
         check_image_size(&file, original_width, original_height);
 
         let blob = BlobObject::new_from_path(&alice, &file).await?;
-        assert_eq!(blob.get_exif_orientation(&alice).unwrap_or(0), orientation);
+        let (_, exif) = blob.metadata()?;
+        if has_exif {
+            let exif = exif.unwrap();
+            assert_eq!(exif_orientation(&exif, &alice), orientation);
+        } else {
+            assert!(exif.is_none());
+        }
 
         let mut msg = Message::new(Viewtype::Image);
         msg.set_file(file.to_str().unwrap(), None);
@@ -1028,7 +1109,8 @@ mod tests {
         let file = bob_msg.get_file(&bob).unwrap();
 
         let blob = BlobObject::new_from_path(&bob, &file).await?;
-        assert_eq!(blob.get_exif_orientation(&bob).unwrap_or(0), 0);
+        let (_, exif) = blob.metadata()?;
+        assert!(exif.is_none());
 
         let img = check_image_size(file, compressed_width, compressed_height);
         Ok(img)

src/chat.rs

@@ -35,8 +35,9 @@ use crate::scheduler::InterruptInfo;
 use crate::smtp::send_msg_to_smtp;
 use crate::stock_str;
 use crate::tools::{
-    create_id, create_outgoing_rfc724_mid, create_smeared_timestamp, create_smeared_timestamps,
-    get_abs_path, gm2local_offset, improve_single_line_input, time, IsNoneOrEmpty,
+    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,
 };
 use crate::webxdc::WEBXDC_SUFFIX;
 use crate::{location, sql};
@@ -247,7 +248,7 @@ impl ChatId {
                 } else {
                     warn!(
                         context,
-                        "Cannot create chat, contact {} does not exist.", contact_id,
+                        "Cannot create chat, contact {contact_id} does not exist."
                     );
                     bail!("Can not create chat for non-existing contact");
                 }
@@ -268,25 +269,26 @@ 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,
+            "Created group/mailinglist '{}' grpid={} as {}, blocked={}.",
+            &grpname,
             grpid,
             chat_id,
             create_blocked,
@@ -302,7 +304,7 @@ impl ChatId {
                 "UPDATE contacts
                 SET selfavatar_sent=?
               WHERE id IN(SELECT contact_id FROM chats_contacts WHERE chat_id=?);",
-                paramsv![timestamp, self],
+                (timestamp, self),
             )
             .await?;
         Ok(())
@@ -319,7 +321,7 @@ impl ChatId {
             .sql
             .execute(
                 "UPDATE chats SET blocked=?1 WHERE id=?2 AND blocked != ?1",
-                paramsv![new_blocked, self],
+                (new_blocked, self),
             )
             .await?;
         Ok(count > 0)
@@ -338,14 +340,14 @@ impl ChatId {
                     if contact_id != ContactId::SELF {
                         info!(
                             context,
-                            "Blocking the contact {} to block 1:1 chat", contact_id
+                            "Blocking the contact {contact_id} to block 1:1 chat."
                         );
                         Contact::block(context, contact_id).await?;
                     }
                 }
             }
             Chattype::Group => {
-                info!(context, "Can't block groups yet, deleting the chat");
+                info!(context, "Can't block groups yet, deleting the chat.");
                 self.delete(context).await?;
             }
             Chattype::Mailinglist => {
@@ -433,10 +435,7 @@ impl ChatId {
 
         context
             .sql
-            .execute(
-                "UPDATE chats SET protected=? WHERE id=?;",
-                paramsv![protect, self],
-            )
+            .execute("UPDATE chats SET protected=? WHERE id=?;", (protect, self))
             .await?;
 
         context.emit_event(EventType::ChatModified(self));
@@ -500,7 +499,7 @@ impl ChatId {
         let chat = Chat::load_from_db(context, self).await?;
 
         if let Err(e) = self.inner_set_protection(context, protect).await {
-            error!(context, "Cannot set protection: {}", e); // make error user-visible
+            error!(context, "Cannot set protection: {e:#}."); // make error user-visible
             return Err(e);
         }
 
@@ -522,12 +521,12 @@ impl ChatId {
                 if visibility == ChatVisibility::Archived {
                     transaction.execute(
                         "UPDATE msgs SET state=? WHERE chat_id=? AND state=?;",
-                        paramsv![MessageState::InNoticed, self, MessageState::InFresh],
+                        (MessageState::InNoticed, self, MessageState::InFresh),
                     )?;
                 }
                 transaction.execute(
                     "UPDATE chats SET archived=? WHERE id=?;",
-                    paramsv![visibility, self],
+                    (visibility, self),
                 )?;
                 Ok(())
             })
@@ -556,7 +555,7 @@ impl ChatId {
                 .execute(
                     "UPDATE chats SET archived=0 WHERE id=? AND archived=1 \
                 AND NOT(muted_until=-1 OR muted_until>?)",
-                    paramsv![self, time()],
+                    (self, time()),
                 )
                 .await?;
             return Ok(());
@@ -574,7 +573,7 @@ impl ChatId {
                 WHERE state=?
                 AND hidden=0
                 AND chat_id=?",
-                    paramsv![MessageState::InFresh, self],
+                    (MessageState::InFresh, self),
                 )
                 .await?;
             if unread_cnt == 1 {
@@ -585,7 +584,7 @@ impl ChatId {
         }
         context
             .sql
-            .execute("UPDATE chats SET archived=0 WHERE id=?", paramsv![self])
+            .execute("UPDATE chats SET archived=0 WHERE id=?", (self,))
             .await?;
         Ok(())
     }
@@ -614,26 +613,23 @@ impl ChatId {
             .sql
             .execute(
                 "DELETE FROM msgs_mdns WHERE msg_id IN (SELECT id FROM msgs WHERE chat_id=?);",
-                paramsv![self],
+                (self,),
             )
             .await?;
 
         context
             .sql
-            .execute("DELETE FROM msgs WHERE chat_id=?;", paramsv![self])
+            .execute("DELETE FROM msgs WHERE chat_id=?;", (self,))
             .await?;
 
         context
             .sql
-            .execute(
-                "DELETE FROM chats_contacts WHERE chat_id=?;",
-                paramsv![self],
-            )
+            .execute("DELETE FROM chats_contacts WHERE chat_id=?;", (self,))
             .await?;
 
         context
             .sql
-            .execute("DELETE FROM chats WHERE id=?;", paramsv![self])
+            .execute("DELETE FROM chats WHERE id=?;", (self,))
             .await?;
 
         context.emit_msgs_changed_without_ids();
@@ -689,7 +685,7 @@ impl ChatId {
             .sql
             .query_get_value(
                 "SELECT id FROM msgs WHERE chat_id=? AND state=?;",
-                paramsv![self, MessageState::OutDraft],
+                (self, MessageState::OutDraft),
             )
             .await?;
         Ok(msg_id)
@@ -771,14 +767,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);
@@ -802,7 +798,7 @@ impl ChatId {
                  hidden,
                  mime_in_reply_to)
          VALUES (?,?,?, ?,?,?,?,?,?);",
-                paramsv![
+                (
                     self,
                     ContactId::SELF,
                     time(),
@@ -812,7 +808,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()?);
@@ -825,7 +821,7 @@ impl ChatId {
             .sql
             .count(
                 "SELECT COUNT(*) FROM msgs WHERE hidden=0 AND chat_id=?",
-                paramsv![self],
+                (self,),
             )
             .await?;
         Ok(count)
@@ -868,7 +864,7 @@ impl ChatId {
                 WHERE state=?
                 AND hidden=0
                 AND chat_id=?;",
-                    paramsv![MessageState::InFresh, self],
+                    (MessageState::InFresh, self),
                 )
                 .await?
         };
@@ -878,7 +874,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=?", paramsv![self])
+            .query_get_value("SELECT param FROM chats WHERE id=?", (self,))
             .await?;
         Ok(res
             .map(|s| s.parse().unwrap_or_default())
@@ -923,13 +919,13 @@ impl ChatId {
         let row = sql
             .query_row_optional(
                 &query,
-                paramsv![
+                (
                     self,
                     MessageState::OutPreparing,
                     MessageState::OutDraft,
                     MessageState::OutPending,
-                    MessageState::OutFailed
-                ],
+                    MessageState::OutFailed,
+                ),
                 f,
             )
             .await?;
@@ -1051,10 +1047,7 @@ 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=?;",
-                paramsv![self],
-            )
+            .query_get_value("SELECT gossiped_timestamp FROM chats WHERE id=?;", (self,))
             .await?;
         Ok(timestamp.unwrap_or_default())
     }
@@ -1070,14 +1063,14 @@ impl ChatId {
         );
         info!(
             context,
-            "set gossiped_timestamp for chat {} to {}.", self, timestamp,
+            "Set gossiped_timestamp for chat {} to {}.", self, timestamp,
         );
 
         context
             .sql
             .execute(
                 "UPDATE chats SET gossiped_timestamp=? WHERE id=?;",
-                paramsv![timestamp, self],
+                (timestamp, self),
             )
             .await?;
 
@@ -1173,7 +1166,7 @@ impl Chat {
                     c.blocked, c.locations_send_until, c.muted_until, c.protected
              FROM chats c
              WHERE c.id=?;",
-                paramsv![chat_id],
+                (chat_id,),
                 |row| {
                     let c = Chat {
                         id: chat_id,
@@ -1211,7 +1204,7 @@ impl Chat {
                     Err(err) => {
                         error!(
                             context,
-                            "failed to load contacts for {}: {:#}", chat.id, err
+                            "Failed to load contacts for {}: {:#}.", chat.id, err
                         );
                     }
                 }
@@ -1287,7 +1280,7 @@ impl Chat {
             .sql
             .execute(
                 "UPDATE chats SET param=? WHERE id=?",
-                paramsv![self.param.to_string(), self.id],
+                (self.param.to_string(), self.id),
             )
             .await?;
         Ok(())
@@ -1469,7 +1462,7 @@ impl Chat {
                 .sql
                 .query_get_value(
                     "SELECT contact_id FROM chats_contacts WHERE chat_id=?;",
-                    paramsv![self.id],
+                    (self.id,),
                 )
                 .await?
             {
@@ -1550,13 +1543,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
             {
@@ -1580,7 +1573,12 @@ impl Chat {
             } else {
                 msg.param.get(Param::SendHtml).map(|s| s.to_string())
             };
-            html.map(|html| new_html_mimepart(html).build().as_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,
+            }
         } else {
             None
         };
@@ -1594,9 +1592,10 @@ 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=?, location_id=?, ephemeral_timer=?, ephemeral_timestamp=?
+                         mime_headers=?, mime_compressed=1, location_id=?, ephemeral_timer=?,
+                         ephemeral_timestamp=?
                      WHERE id=?;",
-                    paramsv![
+                    params_slice![
                         new_rfc724_mid,
                         self.id,
                         ContactId::SELF,
@@ -1640,11 +1639,12 @@ impl Chat {
                         mime_references,
                         mime_modified,
                         mime_headers,
+                        mime_compressed,
                         location_id,
                         ephemeral_timer,
                         ephemeral_timestamp)
-                        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);",
-                    paramsv![
+                        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?,?);",
+                    params_slice![
                         new_rfc724_mid,
                         self.id,
                         ContactId::SELF,
@@ -1666,6 +1666,7 @@ 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?;
@@ -1855,7 +1856,7 @@ async fn update_special_chat_name(
             .sql
             .execute(
                 "UPDATE chats SET name=? WHERE id=? AND name!=?",
-                paramsv![name, chat_id, name],
+                (&name, chat_id, &name),
             )
             .await?;
     }
@@ -1918,7 +1919,7 @@ impl ChatIdBlocked {
                   WHERE c.type=100  -- 100 = Chattype::Single
                     AND c.id>9      -- 9 = DC_CHAT_ID_LAST_SPECIAL
                     AND j.contact_id=?;",
-                paramsv![contact_id],
+                (contact_id,),
                 |row| {
                     let id: ChatId = row.get(0)?;
                     let blocked: Blocked = row.get(1)?;
@@ -1969,13 +1970,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
@@ -1988,7 +1989,7 @@ impl ChatIdBlocked {
                     "INSERT INTO chats_contacts
                  (chat_id, contact_id)
                  VALUES((SELECT last_insert_rowid()), ?)",
-                    params![contact_id],
+                    (contact_id,),
                 )?;
 
                 Ok(chat_id)
@@ -2025,15 +2026,18 @@ 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 blob = msg
+        let mut blob = msg
             .param
             .get_blob(Param::File, context, !msg.is_increation())
             .await?
             .with_context(|| format!("attachment missing for message of type #{}", msg.viewtype))?;
 
         if msg.viewtype == Viewtype::Image {
-            if let Err(e) = blob.recode_to_image_size(context).await {
-                warn!(context, "Cannot recode image, using original data: {:?}", e);
+            if let Err(err) = blob.recode_to_image_size(context).await {
+                warn!(
+                    context,
+                    "Cannot recode image, using original data: {err:#}."
+                );
             }
         }
         msg.param.set(Param::File, blob.as_name());
@@ -2145,7 +2149,7 @@ pub async fn is_contact_in_chat(
         .sql
         .exists(
             "SELECT COUNT(*) FROM chats_contacts WHERE chat_id=? AND contact_id=?;",
-            paramsv![chat_id, contact_id],
+            (chat_id, contact_id),
         )
         .await?;
     Ok(exists)
@@ -2197,6 +2201,13 @@ 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);
 
@@ -2256,7 +2267,7 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
     let attach_selfavatar = match shall_attach_selfavatar(context, msg.chat_id).await {
         Ok(attach_selfavatar) => attach_selfavatar,
         Err(err) => {
-            warn!(context, "job: cannot get selfavatar-state: {:#}", err);
+            warn!(context, "SMTP job cannot get selfavatar-state: {err:#}.");
             false
         }
     };
@@ -2283,7 +2294,7 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
         // may happen eg. for groups with only SELF and bcc_self disabled
         info!(
             context,
-            "message {} has no recipient, skipping smtp-send", msg_id
+            "Message {msg_id} has no recipient, skipping smtp-send."
         );
         msg_id.set_delivered(context).await?;
         return Ok(None);
@@ -2318,27 +2329,27 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
 
     if 0 != rendered_msg.last_added_location_id {
         if let Err(err) = location::set_kml_sent_timestamp(context, msg.chat_id, time()).await {
-            error!(context, "Failed to set kml sent_timestamp: {:#}", err);
+            error!(context, "Failed to set kml sent_timestamp: {err:#}.");
         }
         if !msg.hidden {
             if let Err(err) =
                 location::set_msg_location_id(context, msg.id, rendered_msg.last_added_location_id)
                     .await
             {
-                error!(context, "Failed to set msg_location_id: {:#}", err);
+                error!(context, "Failed to set msg_location_id: {err:#}.");
             }
         }
     }
 
     if let Some(sync_ids) = rendered_msg.sync_ids_to_delete {
         if let Err(err) = context.delete_sync_ids(sync_ids).await {
-            error!(context, "Failed to delete sync ids: {:#}", err);
+            error!(context, "Failed to delete sync ids: {err:#}.");
         }
     }
 
     if attach_selfavatar {
         if let Err(err) = msg.chat_id.set_selfavatar_timestamp(context, time()).await {
-            error!(context, "Failed to set selfavatar timestamp: {:#}", err);
+            error!(context, "Failed to set selfavatar timestamp: {err:#}.");
         }
     }
 
@@ -2359,12 +2370,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))
@@ -2530,7 +2541,7 @@ pub async fn get_chat_msgs_ex(
                     OR m.from_id == ?
                     OR m.to_id == ?
                 );",
-                paramsv![chat_id, ContactId::INFO, ContactId::INFO],
+                (chat_id, ContactId::INFO, ContactId::INFO),
                 process_row,
                 process_rows,
             )
@@ -2543,7 +2554,7 @@ pub async fn get_chat_msgs_ex(
                FROM msgs m
               WHERE m.chat_id=?
                 AND m.hidden=0;",
-                paramsv![chat_id],
+                (chat_id,),
                 process_row,
                 process_rows,
             )
@@ -2561,7 +2572,7 @@ pub(crate) async fn marknoticed_chat_if_older_than(
         .sql
         .query_get_value(
             "SELECT MAX(timestamp) FROM msgs WHERE chat_id=?",
-            paramsv![chat_id],
+            (chat_id,),
         )
         .await?
     {
@@ -2611,7 +2622,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=?;",
-                paramsv![MessageState::InFresh, chat_id],
+                (MessageState::InFresh, chat_id),
             )
             .await?;
         if !exists {
@@ -2626,7 +2637,7 @@ pub async fn marknoticed_chat(context: &Context, chat_id: ChatId) -> Result<()>
               WHERE state=?
                 AND hidden=0
                 AND chat_id=?;",
-                paramsv![MessageState::InNoticed, MessageState::InFresh, chat_id],
+                (MessageState::InNoticed, MessageState::InFresh, chat_id),
             )
             .await?;
     }
@@ -2675,12 +2686,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);
@@ -2693,8 +2704,7 @@ pub(crate) async fn mark_old_messages_as_noticed(
     if !changed_chats.is_empty() {
         info!(
             context,
-            "Marking chats as noticed because there are newer outgoing messages: {:?}",
-            changed_chats
+            "Marking chats as noticed because there are newer outgoing messages: {changed_chats:?}."
         );
     }
 
@@ -2725,12 +2735,14 @@ pub async fn get_chat_media(
             "SELECT id
                FROM msgs
               WHERE (1=? OR chat_id=?)
+                AND chat_id != ?
                 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,
                 msg_type,
                 if msg_type2 != Viewtype::Unknown {
                     msg_type2
@@ -2742,7 +2754,7 @@ pub async fn get_chat_media(
                 } else {
                     msg_type
                 },
-            ],
+            ),
             |row| row.get::<_, MsgId>(0),
             |ids| Ok(ids.flatten().collect()),
         )
@@ -2820,7 +2832,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;",
-            paramsv![chat_id],
+            (chat_id,),
             |row| row.get::<_, ContactId>(0),
             |ids| ids.collect::<Result<Vec<_>, _>>().map_err(Into::into),
         )
@@ -2846,12 +2858,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?;
 
@@ -2884,7 +2896,7 @@ async fn find_unused_broadcast_list_name(context: &Context) -> Result<String> {
             .sql
             .exists(
                 "SELECT COUNT(*) FROM chats WHERE type=? AND name=?;",
-                paramsv![Chattype::Broadcast, better_name],
+                (Chattype::Broadcast, &better_name),
             )
             .await?
         {
@@ -2904,12 +2916,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)?);
@@ -2930,7 +2942,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(?, ?)",
-                    paramsv![chat_id, contact_id],
+                    (chat_id, contact_id),
                 )?;
             }
             Ok(())
@@ -2950,7 +2962,7 @@ pub(crate) async fn remove_from_chat_contacts_table(
         .sql
         .execute(
             "DELETE FROM chats_contacts WHERE chat_id=? AND contact_id=?",
-            paramsv![chat_id, contact_id],
+            (chat_id, contact_id),
         )
         .await?;
     Ok(())
@@ -3015,7 +3027,7 @@ pub(crate) async fn add_contact_to_chat_ex(
         // if SELF is not in the group, members cannot be added at all.
         warn!(
             context,
-            "invalid attempt to add self e-mail address to group"
+            "Invalid attempt to add self e-mail address to group."
         );
         return Ok(false);
     }
@@ -3068,7 +3080,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!=?;",
-            paramsv![chat_id, ContactId::SELF],
+            (chat_id, ContactId::SELF),
             |row| Ok(row.get::<_, i64>(0)),
             |rows| {
                 let mut needs_attach = false;
@@ -3141,7 +3153,7 @@ pub async fn set_muted(context: &Context, chat_id: ChatId, duration: MuteDuratio
         .sql
         .execute(
             "UPDATE chats SET muted_until=? WHERE id=?;",
-            paramsv![duration, chat_id],
+            (duration, chat_id),
         )
         .await
         .context(format!("Failed to set mute duration for {chat_id}"))?;
@@ -3228,10 +3240,7 @@ 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(?);",
-                paramsv![grpid.to_string()],
-            )
+            .execute("INSERT INTO leftgrps (grpid) VALUES(?);", (grpid,))
             .await?;
     }
 
@@ -3241,10 +3250,7 @@ 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=?;",
-            paramsv![grpid],
-        )
+        .exists("SELECT COUNT(*) FROM leftgrps WHERE grpid=?;", (grpid,))
         .await?;
     Ok(exists)
 }
@@ -3276,7 +3282,7 @@ pub async fn set_chat_name(context: &Context, chat_id: ChatId, new_name: &str) -
                 .sql
                 .execute(
                     "UPDATE chats SET name=? WHERE id=?;",
-                    paramsv![new_name.to_string(), chat_id],
+                    (new_name.to_string(), chat_id),
                 )
                 .await?;
             if chat.is_promoted()
@@ -3529,7 +3535,7 @@ pub(crate) async fn get_chat_id_by_grpid(
         .sql
         .query_row_optional(
             "SELECT id, blocked, protected FROM chats WHERE grpid=?;",
-            paramsv![grpid],
+            (grpid,),
             |row| {
                 let chat_id = row.get::<_, ChatId>(0)?;
 
@@ -3562,7 +3568,7 @@ pub async fn add_device_msg_with_importance(
 
     if let Some(label) = label {
         if was_device_msg_ever_added(context, label).await? {
-            info!(context, "device-message {} already added", label);
+            info!(context, "Device-message {label} already added.");
             return Ok(msg_id);
         }
     }
@@ -3583,7 +3589,7 @@ pub async fn add_device_msg_with_importance(
             .sql
             .query_get_value(
                 "SELECT MAX(timestamp) FROM msgs WHERE chat_id=?",
-                paramsv![chat_id],
+                (chat_id,),
             )
             .await?
         {
@@ -3608,7 +3614,7 @@ pub async fn add_device_msg_with_importance(
             param,
             rfc724_mid)
             VALUES (?,?,?,?,?,?,?,?,?,?,?);",
-                paramsv![
+                (
                     chat_id,
                     ContactId::DEVICE,
                     ContactId::SELF,
@@ -3620,9 +3626,10 @@ 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 {
@@ -3633,10 +3640,7 @@ pub async fn add_device_msg_with_importance(
     if let Some(label) = label {
         context
             .sql
-            .execute(
-                "INSERT INTO devmsglabels (label) VALUES (?);",
-                paramsv![label.to_string()],
-            )
+            .execute("INSERT INTO devmsglabels (label) VALUES (?);", (label,))
             .await?;
     }
 
@@ -3663,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=?",
-            paramsv![label],
+            (label,),
         )
         .await?;
 
@@ -3680,10 +3684,7 @@ 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=?;",
-            paramsv![ContactId::DEVICE],
-        )
+        .execute("DELETE FROM msgs WHERE from_id=?;", (ContactId::DEVICE,))
         .await?;
     context.sql.execute("DELETE FROM devmsglabels;", ()).await?;
 
@@ -3726,7 +3727,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,
@@ -3740,8 +3741,9 @@ 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);
@@ -3780,7 +3782,7 @@ pub(crate) async fn update_msg_text_and_timestamp(
         .sql
         .execute(
             "UPDATE msgs SET txt=?, timestamp=? WHERE id=?;",
-            paramsv![text, timestamp, msg_id],
+            (text, timestamp, msg_id),
         )
         .await?;
     context.emit_msgs_changed(chat_id, msg_id);
@@ -3793,8 +3795,10 @@ mod tests {
     use crate::chatlist::{get_archived_cnt, Chatlist};
     use crate::constants::{DC_GCL_ARCHIVED_ONLY, DC_GCL_NO_SPECIALS};
     use crate::contact::{Contact, ContactAddress};
+    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() {
@@ -5975,7 +5979,7 @@ mod tests {
             include_bytes!("../test-data/image/avatar64x64.png"),
         )
         .await?;
-        send_media(
+        let second_image_msg_id = send_media(
             &t,
             chat_id2,
             Viewtype::Image,
@@ -6077,6 +6081,47 @@ mod tests {
             4
         );
 
+        // Delete an image.
+        delete_msgs(&t, &[second_image_msg_id]).await?;
+        assert_eq!(
+            get_chat_media(
+                &t,
+                None,
+                Viewtype::Image,
+                Viewtype::Sticker,
+                Viewtype::Webxdc,
+            )
+            .await?
+            .len(),
+            3
+        );
+
+        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;",
-                paramsv![MessageState::OutDraft, query_contact_id, ChatVisibility::Pinned],
+                (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;",
-                    paramsv![MessageState::OutDraft],
+                    (MessageState::OutDraft,),
                     process_row,
                     process_rows,
                 )
@@ -176,7 +176,7 @@ impl Chatlist {
             // allow searching over special names that may change at any time
             // when the ui calls set_stock_translation()
             if let Err(err) = update_special_chat_names(context).await {
-                warn!(context, "cannot update special chat names: {:?}", err)
+                warn!(context, "Cannot update special chat names: {err:#}.")
             }
 
             let str_like_cmd = format!("%{query}%");
@@ -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;",
-                    paramsv![MessageState::OutDraft, skip_id, str_like_cmd],
+                    (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;",
-                paramsv![MessageState::OutDraft, skip_id, flag_for_forwarding, ChatVisibility::Archived, sort_id_up, ChatVisibility::Pinned],
+                (MessageState::OutDraft, skip_id, flag_for_forwarding, ChatVisibility::Archived, sort_id_up, ChatVisibility::Pinned),
                 process_row,
                 process_rows,
             ).await?;
@@ -356,7 +356,7 @@ pub async fn get_archived_cnt(context: &Context) -> Result<usize> {
         .sql
         .count(
             "SELECT COUNT(*) FROM chats WHERE blocked!=? AND archived=?;",
-            paramsv![Blocked::Yes, ChatVisibility::Archived],
+            (Blocked::Yes, ChatVisibility::Archived),
         )
         .await?;
     Ok(count)

src/config.rs

@@ -308,6 +308,9 @@ 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 {
@@ -358,6 +361,11 @@ 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())
@@ -459,6 +467,12 @@ 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,4 +1,13 @@
-//! Email accounts autoconfiguration process module.
+//! # 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
 
 mod auto_mozilla;
 mod auto_outlook;
@@ -156,7 +165,9 @@ 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
-                    .ok_or_log_msg(context, "Cannot add AEAP explanation");
+                    .context("Cannot add AEAP explanation")
+                    .log_err(context)
+                    .ok();
             }
         }
     }

src/configure/auto_mozilla.rs

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

src/constants.rs

@@ -192,11 +192,15 @@ 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
+// max. width/height of images scaled down because of being too huge
 pub const BALANCED_IMAGE_SIZE: u32 = 1280;
 pub const WORSE_IMAGE_SIZE: u32 = 640;
 

src/contact.rs

@@ -32,7 +32,10 @@ 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, time, EmailAddress};
+use crate::tools::{
+    duration_to_str, get_abs_path, improve_single_line_input, strip_rtlo_characters, time,
+    EmailAddress,
+};
 use crate::{chat, stock_str};
 
 /// Time during which a contact is considered as seen recently.
@@ -344,7 +347,7 @@ impl Contact {
                 c.authname, c.param, c.status
                FROM contacts c
               WHERE c.id=?;",
-                paramsv![contact_id],
+                (contact_id,),
                 |row| {
                     let name: String = row.get(0)?;
                     let addr: String = row.get(1)?;
@@ -457,7 +460,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE msgs SET state=? WHERE from_id=? AND state=?;",
-                paramsv![MessageState::InNoticed, id, MessageState::InFresh],
+                (MessageState::InNoticed, id, MessageState::InFresh),
             )
             .await?;
         Ok(())
@@ -490,7 +493,7 @@ impl Contact {
                 "SELECT id FROM contacts \
             WHERE addr=?1 COLLATE NOCASE \
             AND id>?2 AND origin>=?3 AND blocked=0;",
-                paramsv![addr_normalized, ContactId::LAST_SPECIAL, min_origin as u32,],
+                (&addr_normalized, ContactId::LAST_SPECIAL, min_origin as u32),
             )
             .await?;
         Ok(id)
@@ -536,7 +539,7 @@ impl Contact {
             return Ok((ContactId::SELF, sth_modified));
         }
 
-        let mut name = name;
+        let mut name = strip_rtlo_characters(name);
         #[allow(clippy::collapsible_if)]
         if origin <= Origin::OutgoingTo {
             // The user may accidentally have written to a "noreply" address with another MUA:
@@ -551,7 +554,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 = "";
+                name = "".to_string();
             }
         }
 
@@ -605,7 +608,7 @@ impl Contact {
                     transaction
                         .execute(
                             "UPDATE contacts SET name=?, addr=?, origin=?, authname=? WHERE id=?;",
-                            paramsv![
+                            (
                                 new_name,
                                 if update_addr {
                                     addr.to_string()
@@ -623,7 +626,7 @@ impl Contact {
                                     row_authname
                                 },
                                 row_id
-                            ],
+                            ),
                         )?;
 
                     if update_name || update_authname {
@@ -631,7 +634,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=?)",
-                            params![Chattype::Single, isize::try_from(row_id)?],
+                            (Chattype::Single, isize::try_from(row_id)?),
                             |row| {
                                 let chat_id: ChatId = row.get(0)?;
                                 Ok(chat_id)
@@ -645,7 +648,7 @@ impl Contact {
                                     "SELECT addr, name, authname
                                      FROM contacts
                                      WHERE id=?",
-                                     params![contact_id],
+                                     (contact_id,),
                                 |row| {
                                     let addr: String = row.get(0)?;
                                     let name: String = row.get(1)?;
@@ -663,7 +666,7 @@ impl Contact {
 
                             let count = transaction.execute(
                                     "UPDATE chats SET name=?1 WHERE id=?2 AND name!=?1",
-                                    params![chat_name, chat_id])?;
+                                    (chat_name, chat_id))?;
 
                             if count > 0 {
                                 // Chat name updated
@@ -681,7 +684,7 @@ impl Contact {
                     .execute(
                         "INSERT INTO contacts (name, addr, origin, authname)
                          VALUES (?, ?, ?, ?);",
-                        params![
+                         (
                             if update_name {
                                 name.to_string()
                             } else {
@@ -694,7 +697,7 @@ impl Contact {
                             } else {
                                 "".to_string()
                             }
-                        ],
+                        ),
                     )?;
 
                 sth_modified = Modifier::Created;
@@ -795,12 +798,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_iterv![
+                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
                         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| {
@@ -847,7 +850,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_iterv![
+                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
                         ContactId::LAST_SPECIAL,
                         Origin::IncomingReplyTo
                     ])),
@@ -880,7 +883,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(params![Chattype::Mailinglist, Blocked::Yes], |row| {
+                let rows = stmt.query_map((Chattype::Mailinglist, Blocked::Yes), |row| {
                     let name: String = row.get(0)?;
                     let grpid: String = row.get(1)?;
                     Ok((name, grpid))
@@ -902,7 +905,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=?",
-                        params![&name, Origin::MailinglistAddress, &grpid],
+                        (&name, Origin::MailinglistAddress, &grpid),
                     )?;
                 }
                 Ok(())
@@ -917,7 +920,7 @@ impl Contact {
             .sql
             .count(
                 "SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0",
-                paramsv![ContactId::LAST_SPECIAL],
+                (ContactId::LAST_SPECIAL,),
             )
             .await?;
         Ok(count)
@@ -933,7 +936,7 @@ impl Contact {
             .sql
             .query_map(
                 "SELECT id FROM contacts WHERE id>? AND blocked!=0 ORDER BY last_seen DESC, id DESC;",
-                paramsv![ContactId::LAST_SPECIAL],
+                (ContactId::LAST_SPECIAL,),
                 |row| row.get::<_, ContactId>(0),
                 |ids| {
                     ids.collect::<std::result::Result<Vec<_>, _>>()
@@ -1027,12 +1030,12 @@ impl Contact {
                 let deleted_contacts = transaction.execute(
                     "DELETE FROM contacts WHERE id=?
                      AND (SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?)=0;",
-                    paramsv![contact_id, contact_id],
+                    (contact_id, contact_id),
                 )?;
                 if deleted_contacts == 0 {
                     transaction.execute(
                         "UPDATE contacts SET origin=? WHERE id=?;",
-                        paramsv![Origin::Hidden, contact_id],
+                        (Origin::Hidden, contact_id),
                     )?;
                 }
                 Ok(())
@@ -1060,7 +1063,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE contacts SET param=? WHERE id=?",
-                paramsv![self.param.to_string(), self.id],
+                (self.param.to_string(), self.id),
             )
             .await?;
         Ok(())
@@ -1072,7 +1075,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE contacts SET status=? WHERE id=?",
-                paramsv![self.status, self.id],
+                (&self.status, self.id),
             )
             .await?;
         Ok(())
@@ -1192,9 +1195,7 @@ impl Contact {
             if peerstate.verified_key.is_some() {
                 return Ok(VerifiedStatus::BidirectVerified);
             }
-        }
-
-        if let Some(peerstate) = Peerstate::from_addr(context, &self.addr).await? {
+        } else if let Some(peerstate) = Peerstate::from_addr(context, &self.addr).await? {
             if peerstate.verified_key.is_some() {
                 return Ok(VerifiedStatus::BidirectVerified);
             }
@@ -1230,7 +1231,7 @@ impl Contact {
             .sql
             .count(
                 "SELECT COUNT(*) FROM contacts WHERE id>?;",
-                paramsv![ContactId::LAST_SPECIAL],
+                (ContactId::LAST_SPECIAL,),
             )
             .await?;
         Ok(count)
@@ -1244,10 +1245,7 @@ impl Contact {
 
         let exists = context
             .sql
-            .exists(
-                "SELECT COUNT(*) FROM contacts WHERE id=?;",
-                paramsv![contact_id],
-            )
+            .exists("SELECT COUNT(*) FROM contacts WHERE id=?;", (contact_id,))
             .await?;
         Ok(exists)
     }
@@ -1262,7 +1260,7 @@ impl Contact {
             .sql
             .execute(
                 "UPDATE contacts SET origin=? WHERE id=? AND origin<?;",
-                paramsv![origin, contact_id, origin],
+                (origin, contact_id, origin),
             )
             .await?;
         Ok(())
@@ -1291,18 +1289,20 @@ 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() {
-                captures
-                    .get(1)
-                    .map_or("".to_string(), |m| normalize_name(m.as_str()))
+                strip_rtlo_characters(
+                    &captures
+                        .get(1)
+                        .map_or("".to_string(), |m| normalize_name(m.as_str())),
+                )
             } else {
-                name.to_string()
+                strip_rtlo_characters(name)
             },
             captures
                 .get(2)
                 .map_or("".to_string(), |m| m.as_str().to_string()),
         )
     } else {
-        (name.to_string(), addr.to_string())
+        (strip_rtlo_characters(name), addr.to_string())
     }
 }
 
@@ -1324,7 +1324,7 @@ async fn set_block_contact(
             .sql
             .execute(
                 "UPDATE contacts SET blocked=? WHERE id=?;",
-                paramsv![i32::from(new_blocking), contact_id],
+                (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=?
 );
 "#,
-                paramsv![new_blocking, Chattype::Single, contact_id],
+                (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",
-            paramsv![timestamp, contact_id],
+            (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().into()),
+            .map_or("".to_string(), |s| s.trim().to_string()),
         _ => full_name.to_string(),
     }
 }
@@ -1575,7 +1575,7 @@ impl RecentlySeenLoop {
             .query_map(
                 "SELECT id, last_seen FROM contacts
                  WHERE last_seen > ?",
-                paramsv![time() - SEEN_RECENTLY_SECONDS],
+                (time() - SEEN_RECENTLY_SECONDS,),
                 |row| {
                     let contact_id: ContactId = row.get("id")?;
                     let last_seen: i64 = row.get("last_seen")?;

src/context.rs

@@ -11,14 +11,13 @@ 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, RwLock};
-use tokio::task;
+use tokio::sync::{Mutex, Notify, RwLock};
 
 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::DebugEventLogData;
+use crate::debug_logging::DebugLogging;
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::key::{DcKey, SignedPublicKey};
 use crate::login_param::LoginParam;
@@ -218,6 +217,11 @@ 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>
@@ -239,18 +243,10 @@ pub struct InnerContext {
     pub(crate) last_error: std::sync::RwLock<String>,
 
     /// If debug logging is enabled, this contains all necessary information
-    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>,
+    ///
+    /// 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>>,
 }
 
 /// The state of ongoing process.
@@ -260,7 +256,7 @@ enum RunningState {
     Running { cancel_sender: Sender<()> },
 
     /// Cancel signal has been sent, waiting for ongoing process to be freed.
-    ShallStop,
+    ShallStop { request: Instant },
 
     /// There is no ongoing process, a new one can be allocated.
     Stopped,
@@ -363,6 +359,11 @@ 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,
@@ -379,11 +380,12 @@ 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: RwLock::new(None),
+            debug_logging: std::sync::RwLock::new(None),
         };
 
         let ctx = Context {
@@ -438,41 +440,18 @@ 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)
         {
-            self.send_log_event(event.clone()).ok();
-        };
+            let lock = self.debug_logging.read().expect("RwLock is poisoned");
+            if let Some(debug_logging) = &*lock {
+                debug_logging.log_event(event.clone());
+            }
+        }
         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 {
@@ -530,6 +509,9 @@ impl Context {
 
     pub(crate) async fn free_ongoing(&self) {
         let mut s = self.running_state.write().await;
+        if let RunningState::ShallStop { request } = *s {
+            info!(self, "Ongoing stopped in {:?}", request.elapsed());
+        }
         *s = RunningState::Stopped;
     }
 
@@ -542,9 +524,11 @@ impl Context {
                     warn!(self, "could not cancel ongoing: {:#}", err);
                 }
                 info!(self, "Signaling the ongoing process to stop ASAP.",);
-                *s = RunningState::ShallStop;
+                *s = RunningState::ShallStop {
+                    request: Instant::now(),
+                };
             }
-            RunningState::ShallStop | RunningState::Stopped => {
+            RunningState::ShallStop { .. } | RunningState::Stopped => {
                 info!(self, "No ongoing process to stop.",);
             }
         }
@@ -554,7 +538,7 @@ impl Context {
     pub(crate) async fn shall_stop_ongoing(&self) -> bool {
         match &*self.running_state.read().await {
             RunningState::Running { .. } => false,
-            RunningState::ShallStop | RunningState::Stopped => true,
+            RunningState::ShallStop { .. } | RunningState::Stopped => true,
         }
     }
 
@@ -767,6 +751,10 @@ 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()));
@@ -799,7 +787,7 @@ impl Context {
                     "   AND NOT(c.muted_until=-1 OR c.muted_until>?)",
                     " ORDER BY m.timestamp DESC,m.id DESC;"
                 ),
-                paramsv![MessageState::InFresh, time()],
+                (MessageState::InFresh, time()),
                 |row| row.get::<_, MsgId>(0),
                 |rows| {
                     let mut list = Vec::new();
@@ -813,6 +801,66 @@ 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`
@@ -824,24 +872,10 @@ 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 {
-            do_query(
-                "SELECT m.id AS id
+            self.sql
+                .query_map(
+                    "SELECT m.id AS id
                  FROM msgs m
                  LEFT JOIN contacts ct
                         ON m.from_id=ct.id
@@ -850,9 +884,17 @@ impl Context {
                    AND ct.blocked=0
                    AND txt LIKE ?
                  ORDER BY m.timestamp,m.id;",
-                paramsv![chat_id, str_like_in_text],
-            )
-            .await?
+                    (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?
         } else {
             // For performance reasons results are sorted only by `id`, that is in the order of
             // message reception.
@@ -864,8 +906,9 @@ 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.
-            do_query(
-                "SELECT m.id AS id
+            self.sql
+                .query_map(
+                    "SELECT m.id AS id
                  FROM msgs m
                  LEFT JOIN contacts ct
                         ON m.from_id=ct.id
@@ -877,9 +920,17 @@ impl Context {
                    AND ct.blocked=0
                    AND m.txt LIKE ?
                  ORDER BY m.id DESC LIMIT 1000",
-                paramsv![str_like_in_text],
-            )
-            .await?
+                    (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?
         };
 
         Ok(list)
@@ -1089,7 +1140,7 @@ mod tests {
         t.sql
             .execute(
                 "UPDATE chats SET muted_until=? WHERE id=?;",
-                paramsv![time() - 3600, bob.id],
+                (time() - 3600, bob.id),
             )
             .await
             .unwrap();
@@ -1106,10 +1157,7 @@ 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=?;",
-                paramsv![bob.id],
-            )
+            .execute("UPDATE chats SET muted_until=-2 WHERE id=?;", (bob.id,))
             .await
             .unwrap();
         let bob = Chat::load_from_db(&t, bob.id).await.unwrap();
@@ -1444,4 +1492,38 @@ 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,17 +2,41 @@
 use crate::{
     chat::ChatId,
     config::Config,
-    context::{Context, DebugLogging},
+    context::Context,
     message::{Message, MsgId, Viewtype},
     param::Param,
+    tools::time,
     webxdc::StatusUpdateItem,
-    Event, EventType,
+    EventType,
 };
-use async_channel::{self as channel, Receiver};
+use async_channel::{self as channel, Receiver, Sender};
 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,
@@ -48,12 +72,9 @@ pub async fn debug_logging_loop(context: &Context, events: Receiver<DebugEventLo
                 eprintln!("Can't log event to webxdc status update: {err:#}");
             }
             Ok(serial) => {
-                context.events.emit(Event {
-                    id: context.id,
-                    typ: EventType::WebxdcStatusUpdate {
-                        msg_id,
-                        status_update_serial: serial,
-                    },
+                context.emit_event(EventType::WebxdcStatusUpdate {
+                    msg_id,
+                    status_update_serial: serial,
                 });
             }
         }
@@ -112,24 +133,26 @@ 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().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,
-                    });
+            {
+                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,
+                        });
+                    }
                 }
             }
             info!(ctx, "replacing logging webxdc");
@@ -139,7 +162,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().await = None;
+            *ctx.debug_logging.write().expect("RwLock is poisoned") = None;
             info!(ctx, "removing logging webxdc");
         }
     }

src/download.rs

@@ -101,7 +101,7 @@ impl MsgId {
             .sql
             .execute(
                 "UPDATE msgs SET download_state=? WHERE id=?;",
-                paramsv![download_state, self],
+                (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",
-                    paramsv![msg.rfc724_mid],
+                    (&msg.rfc724_mid,),
                     |row| {
                         let server_uid: u32 = row.get(0)?;
                         let server_folder: String = row.get(1)?;

src/ephemeral.rs

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

src/events.rs

@@ -1,15 +1,10 @@
 //! # Events specification.
 
-use std::path::PathBuf;
-
 use async_channel::{self as channel, Receiver, Sender, TrySendError};
-use serde::Serialize;
 
-use crate::chat::ChatId;
-use crate::contact::ContactId;
-use crate::ephemeral::Timer as EphemeralTimer;
-use crate::message::MsgId;
-use crate::webxdc::StatusUpdateSerial;
+mod payload;
+
+pub use self::payload::EventType;
 
 /// Event channel.
 #[derive(Debug, Clone)]
@@ -32,7 +27,9 @@ impl Events {
         Self { receiver, sender }
     }
 
-    /// Emits an event.
+    /// Emits an event into event channel.
+    ///
+    /// If the channel is full, deletes the oldest event first.
     pub fn emit(&self, event: Event) {
         match self.sender.try_send(event) {
             Ok(()) => {}
@@ -49,7 +46,7 @@ impl Events {
         }
     }
 
-    /// Retrieve the event emitter.
+    /// Creates an event emitter.
     pub fn get_emitter(&self) -> EventEmitter {
         EventEmitter(self.receiver.clone())
     }
@@ -108,248 +105,3 @@ 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 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

@@ -0,0 +1,258 @@
+//! # 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;
+use futures::{StreamExt, TryStreamExt};
 use num_traits::FromPrimitive;
 
 use crate::chat::{self, ChatId, ChatIdBlocked};
@@ -516,8 +516,7 @@ impl Imap {
             .uid_fetch("1:*", RFC724MID_UID)
             .await
             .with_context(|| format!("can't resync folder {folder}"))?;
-        while let Some(fetch) = list.next().await {
-            let fetch = fetch?;
+        while let Some(fetch) = list.try_next().await? {
             let headers = match get_fetch_headers(&fetch) {
                 Ok(headers) => headers,
                 Err(err) => {
@@ -551,7 +550,7 @@ impl Imap {
         context
             .sql
             .transaction(move |transaction| {
-                transaction.execute("DELETE FROM imap WHERE folder=?", params![folder])?;
+                transaction.execute("DELETE FROM imap WHERE folder=?", (folder,))?;
                 for (uid, (rfc724_mid, target)) in &msgs {
                     // This may detect previously undetected moved
                     // messages, so we update server_folder too.
@@ -561,7 +560,7 @@ impl Imap {
                          ON CONFLICT(folder, uid, uidvalidity)
                          DO UPDATE SET rfc724_mid=excluded.rfc724_mid,
                                        target=excluded.target",
-                        params![rfc724_mid, folder, uid, uid_validity, target],
+                        (rfc724_mid, folder, uid, uid_validity, target),
                     )?;
                 }
                 Ok(())
@@ -660,7 +659,7 @@ impl Imap {
                     .context("Error fetching UID")?;
 
                 let mut new_last_seen_uid = None;
-                while let Some(fetch) = list.next().await.transpose()? {
+                while let Some(fetch) = list.try_next().await? {
                     if fetch.message == mailbox.exists && fetch.uid.is_some() {
                         new_last_seen_uid = fetch.uid;
                     }
@@ -677,7 +676,7 @@ impl Imap {
             .sql
             .execute(
                 "DELETE FROM imap WHERE folder=? AND uidvalidity!=?",
-                paramsv![folder, new_uid_validity],
+                (&folder, new_uid_validity),
             )
             .await?;
 
@@ -760,7 +759,7 @@ impl Imap {
                        ON CONFLICT(folder, uid, uidvalidity)
                        DO UPDATE SET rfc724_mid=excluded.rfc724_mid,
                                      target=excluded.target",
-                    paramsv![message_id, folder, uid, uid_validity, &target],
+                    (&message_id, &folder, uid, uid_validity, &target),
                 )
                 .await?;
 
@@ -1051,7 +1050,7 @@ impl Session {
         WHERE folder = ?
         AND target != folder
         ORDER BY target, uid",
-                paramsv![folder],
+                (folder,),
                 |row| {
                     let rowid: i64 = row.get(0)?;
                     let uid: u32 = row.get(1)?;
@@ -1198,8 +1197,11 @@ impl Imap {
             .await
             .context("failed to fetch flags")?;
 
-        while let Some(fetch) = list.next().await {
-            let fetch = fetch.context("failed to get FETCH result")?;
+        while let Some(fetch) = list
+            .try_next()
+            .await
+            .context("failed to get FETCH result")?
+        {
             let uid = if let Some(uid) = fetch.uid {
                 uid
             } else {
@@ -1258,8 +1260,7 @@ impl Imap {
                 .await
                 .context("IMAP Could not fetch")?;
 
-            while let Some(fetch) = list.next().await {
-                let msg = fetch?;
+            while let Some(msg) = list.try_next().await? {
                 match get_fetch_headers(&msg) {
                     Ok(headers) => {
                         if let Some(from) = mimeparser::get_from(&headers) {
@@ -1294,8 +1295,7 @@ impl Imap {
             .context("IMAP could not fetch")?;
 
         let mut msgs = BTreeMap::new();
-        while let Some(fetch) = list.next().await {
-            let msg = fetch?;
+        while let Some(msg) = list.try_next().await? {
             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
@@ -1332,8 +1332,7 @@ impl Imap {
             .context("IMAP Could not fetch")?;
 
         let mut msgs = BTreeMap::new();
-        while let Some(fetch) = list.next().await {
-            let msg = fetch?;
+        while let Some(msg) = list.try_next().await? {
             if let Some(msg_uid) = msg.uid {
                 msgs.insert((msg.internal_date(), msg_uid), msg);
             }
@@ -1680,8 +1679,7 @@ impl Imap {
         let mut delimiter_is_default = true;
         let mut folder_configs = BTreeMap::new();
 
-        while let Some(folder) = folders.next().await {
-            let folder = folder?;
+        while let Some(folder) = folders.try_next().await? {
             info!(context, "Scanning folder: {:?}", folder);
 
             // Update the delimiter iff there is a different one, but only once.
@@ -1742,17 +1740,37 @@ 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 {
-                UnsolicitedResponse::Exists(_) => {
+                Exists(_) => {
                     info!(
                         context,
                         "Need to fetch again, got unsolicited EXISTS {:?}", response
                     );
                     unsolicited_exists = true;
                 }
-                _ => info!(context, "ignoring unsolicited response {:?}", response),
+
+                // 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)
+                }
             }
         }
         Ok(unsolicited_exists)
@@ -2170,7 +2188,7 @@ async fn mark_seen_by_uid(
                    AND uid=?3
                    LIMIT 1
                  )",
-            paramsv![&folder, uid_validity, uid],
+            (&folder, uid_validity, uid),
             |row| {
                 let msg_id: MsgId = row.get(0)?;
                 let chat_id: ChatId = row.get(1)?;
@@ -2186,12 +2204,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"))?
@@ -2221,7 +2239,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=?",
-            paramsv![message_id],
+            (message_id,),
         )
         .await?;
     context
@@ -2241,7 +2259,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",
-            paramsv![folder, uid_next],
+            (folder, uid_next),
         )
         .await?;
     Ok(())
@@ -2255,10 +2273,7 @@ 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=?;",
-            paramsv![folder],
-        )
+        .query_get_value("SELECT uid_next FROM imap_sync WHERE folder=?;", (folder,))
         .await?
         .unwrap_or(0))
 }
@@ -2273,7 +2288,7 @@ pub(crate) async fn set_uidvalidity(
         .execute(
             "INSERT INTO imap_sync (folder, uidvalidity) VALUES (?,?)
                 ON CONFLICT(folder) DO UPDATE SET uidvalidity=excluded.uidvalidity",
-            paramsv![folder, uidvalidity],
+            (folder, uidvalidity),
         )
         .await?;
     Ok(())
@@ -2284,7 +2299,7 @@ async fn get_uidvalidity(context: &Context, folder: &str) -> Result<u32> {
         .sql
         .query_get_value(
             "SELECT uidvalidity FROM imap_sync WHERE folder=?;",
-            paramsv![folder],
+            (folder,),
         )
         .await?
         .unwrap_or(0))
@@ -2296,7 +2311,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",
-            paramsv![folder, modseq],
+            (folder, modseq),
         )
         .await?;
     Ok(())
@@ -2305,10 +2320,7 @@ 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=?;",
-            paramsv![folder],
-        )
+        .query_get_value("SELECT modseq FROM imap_sync WHERE folder=?;", (folder,))
         .await?
         .unwrap_or(0))
 }

src/imap/scan_folders.rs

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

src/imex.rs

@@ -91,15 +91,13 @@ pub async fn imex(
     let cancel = context.alloc_ongoing().await?;
 
     let res = {
-        let mut guard = context.scheduler.pause(context.clone()).await;
-        let res = imex_inner(context, what, path, passphrase)
+        let _guard = context.scheduler.pause(context.clone()).await?;
+        imex_inner(context, what, path, passphrase)
             .race(async {
                 cancel.recv().await.ok();
                 Err(format_err!("canceled"))
             })
-            .await;
-        guard.resume().await;
-        res
+            .await
     };
     context.free_ongoing().await;
 
@@ -399,8 +397,7 @@ async fn imex_inner(
             export_backup(context, path, passphrase.unwrap_or_default()).await
         }
         ImexMode::ImportBackup => {
-            import_backup(context, path, passphrase.unwrap_or_default()).await?;
-            context.sql.run_migrations(context).await
+            import_backup(context, path, passphrase.unwrap_or_default()).await
         }
     }
 }
@@ -476,6 +473,7 @@ async fn import_backup(
         }
     }
 
+    context.sql.run_migrations(context).await?;
     delete_and_reset_all_device_msgs(context).await?;
 
     Ok(())
@@ -761,18 +759,15 @@ 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.ok_or_log(context);
+    sql::housekeeping(context).await.log_err(context).ok();
     context
         .sql
         .call_write(|conn| {
-            conn.execute("VACUUM;", params![])
+            conn.execute("VACUUM;", ())
                 .map_err(|err| warn!(context, "Vacuum failed, exporting anyway {err}"))
                 .ok();
-            conn.execute(
-                "ATTACH DATABASE ? AS backup KEY ?",
-                paramsv![dest, passphrase],
-            )
-            .context("failed to attach backup database")?;
+            conn.execute("ATTACH DATABASE ? AS backup KEY ?", (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

@@ -32,7 +32,8 @@ use std::task::Poll;
 use anyhow::{anyhow, bail, ensure, format_err, Context as _, Result};
 use async_channel::Receiver;
 use futures_lite::StreamExt;
-use iroh::get::{DataStream, Options};
+use iroh::blobs::Collection;
+use iroh::get::DataStream;
 use iroh::progress::ProgressEmitter;
 use iroh::protocol::AuthToken;
 use iroh::provider::{DataSource, Event, Provider, Ticket};
@@ -43,15 +44,20 @@ use tokio::sync::broadcast::error::RecvError;
 use tokio::sync::{broadcast, Mutex};
 use tokio::task::{JoinHandle, JoinSet};
 use tokio_stream::wrappers::ReadDirStream;
+use tokio_util::sync::CancellationToken;
 
 use crate::blob::BlobDirContents;
-use crate::chat::delete_and_reset_all_device_msgs;
+use crate::chat::{add_device_msg, delete_and_reset_all_device_msgs};
 use crate::context::Context;
-use crate::qr::Qr;
+use crate::message::{Message, Viewtype};
+use crate::qr::{self, Qr};
+use crate::stock_str::backup_transfer_msg_body;
 use crate::{e2ee, EventType};
 
 use super::{export_database, DBFILE_BACKUP_NAME};
 
+const MAX_CONCURRENT_DIALS: u8 = 16;
+
 /// Provide or send a backup of this device.
 ///
 /// This creates a backup of the current device and starts a service which offers another
@@ -71,6 +77,8 @@ pub struct BackupProvider {
     handle: JoinHandle<Result<()>>,
     /// The ticket to retrieve the backup collection.
     ticket: Ticket,
+    /// Guard to cancel the provider on drop.
+    _drop_guard: tokio_util::sync::DropGuard,
 }
 
 impl BackupProvider {
@@ -91,11 +99,11 @@ impl BackupProvider {
 
         // Acquire global "ongoing" mutex.
         let cancel_token = context.alloc_ongoing().await?;
-        let mut 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(anyhow!("Context dir not found"))?;
+            .ok_or_else(|| 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?;
@@ -119,21 +127,28 @@ impl BackupProvider {
             Ok((provider, ticket)) => (provider, ticket),
             Err(err) => {
                 context.free_ongoing().await;
-                paused_guard.resume().await;
                 return Err(err);
             }
         };
+        let drop_token = CancellationToken::new();
         let handle = {
             let context = context.clone();
+            let drop_token = drop_token.clone();
             tokio::spawn(async move {
-                let res = Self::watch_provider(&context, provider, cancel_token).await;
+                let res = Self::watch_provider(&context, provider, cancel_token, drop_token).await;
                 context.free_ongoing().await;
-                paused_guard.resume().await;
+
+                // Explicit drop to move the guards into this future
+                drop(paused_guard);
                 drop(dbfile);
                 res
             })
         };
-        Ok(Self { handle, ticket })
+        Ok(Self {
+            handle,
+            ticket,
+            _drop_guard: drop_token.drop_guard(),
+        })
     }
 
     /// Creates the provider task.
@@ -169,7 +184,7 @@ impl BackupProvider {
             .spawn()?;
         context.emit_event(SendProgress::ProviderListening.into());
         info!(context, "Waiting for remote to connect");
-        let ticket = provider.ticket(hash);
+        let ticket = provider.ticket(hash)?;
         Ok((provider, ticket))
     }
 
@@ -187,8 +202,8 @@ impl BackupProvider {
         context: &Context,
         mut provider: Provider,
         cancel_token: Receiver<()>,
+        drop_token: CancellationToken,
     ) -> Result<()> {
-        // _dbfile exists so we can clean up the file once it is no longer needed
         let mut events = provider.subscribe();
         let mut total_size = 0;
         let mut current_size = 0;
@@ -248,12 +263,21 @@ impl BackupProvider {
                 },
                 _ = cancel_token.recv() => {
                     provider.shutdown();
-                    break Err(anyhow!("BackupSender cancelled"));
+                    break Err(anyhow!("BackupProvider cancelled"));
                 },
+                _ = drop_token.cancelled() => {
+                    provider.shutdown();
+                    break Err(anyhow!("BackupProvider dropped"));
+                }
             }
         };
         match &res {
-            Ok(_) => context.emit_event(SendProgress::Completed.into()),
+            Ok(_) => {
+                context.emit_event(SendProgress::Completed.into());
+                let mut msg = Message::new(Viewtype::Text);
+                msg.text = Some(backup_transfer_msg_body(context).await);
+                add_device_msg(context, None, Some(&mut msg)).await?;
+            }
             Err(err) => {
                 error!(context, "Backup transfer failure: {err:#}");
                 context.emit_event(SendProgress::Failed.into())
@@ -369,19 +393,20 @@ pub async fn get_backup(context: &Context, qr: Qr) -> Result<()> {
         !context.is_configured().await?,
         "Cannot import backups to accounts in use."
     );
-    let mut guard = context.scheduler.pause(context.clone()).await;
-
     // Acquire global "ongoing" mutex.
     let cancel_token = context.alloc_ongoing().await?;
+    let _guard = context.scheduler.pause(context.clone()).await;
+    info!(
+        context,
+        "Running get_backup for {}",
+        qr::format_backup(&qr)?
+    );
     let res = tokio::select! {
         biased;
-        res = get_backup_inner(context, qr) => {
-            context.free_ongoing().await;
-            res
-        }
+        res = get_backup_inner(context, qr) => res,
         _ = cancel_token.recv() => Err(format_err!("cancelled")),
     };
-    guard.resume().await;
+    context.free_ongoing().await;
     res
 }
 
@@ -390,104 +415,68 @@ async fn get_backup_inner(context: &Context, qr: Qr) -> Result<()> {
         Qr::Backup { ticket } => ticket,
         _ => bail!("QR code for backup must be of type DCBACKUP"),
     };
-    if ticket.addrs.is_empty() {
-        bail!("ticket is missing addresses to dial");
-    }
-    for addr in &ticket.addrs {
-        let opts = Options {
-            addr: *addr,
-            peer_id: Some(ticket.peer),
-            keylog: false,
-        };
-        info!(context, "attempting to contact {}", addr);
-        match transfer_from_provider(context, &ticket, opts).await {
-            Ok(_) => {
-                delete_and_reset_all_device_msgs(context).await?;
-                context.emit_event(ReceiveProgress::Completed.into());
-                return Ok(());
-            }
-            Err(TransferError::ConnectionError(err)) => {
-                warn!(context, "Connection error: {err:#}.");
-                continue;
-            }
-            Err(TransferError::Other(err)) => {
-                // Clean up any blobs we already wrote.
-                let readdir = fs::read_dir(context.get_blobdir()).await?;
-                let mut readdir = ReadDirStream::new(readdir);
-                while let Some(dirent) = readdir.next().await {
-                    if let Ok(dirent) = dirent {
-                        fs::remove_file(dirent.path()).await.ok();
-                    }
+
+    match transfer_from_provider(context, &ticket).await {
+        Ok(()) => {
+            context.sql.run_migrations(context).await?;
+            delete_and_reset_all_device_msgs(context).await?;
+            context.emit_event(ReceiveProgress::Completed.into());
+            Ok(())
+        }
+        Err(err) => {
+            // Clean up any blobs we already wrote.
+            let readdir = fs::read_dir(context.get_blobdir()).await?;
+            let mut readdir = ReadDirStream::new(readdir);
+            while let Some(dirent) = readdir.next().await {
+                if let Ok(dirent) = dirent {
+                    fs::remove_file(dirent.path()).await.ok();
                 }
-                context.emit_event(ReceiveProgress::Failed.into());
-                return Err(err);
             }
+            context.emit_event(ReceiveProgress::Failed.into());
+            Err(err)
         }
     }
-    Err(anyhow!("failed to contact provider"))
 }
 
-/// Error during a single transfer attempt.
-///
-/// Mostly exists to distinguish between `ConnectionError` and any other errors.
-#[derive(Debug, thiserror::Error)]
-enum TransferError {
-    #[error("connection error")]
-    ConnectionError(#[source] anyhow::Error),
-    #[error("other")]
-    Other(#[source] anyhow::Error),
-}
-
-async fn transfer_from_provider(
-    context: &Context,
-    ticket: &Ticket,
-    opts: Options,
-) -> Result<(), TransferError> {
+async fn transfer_from_provider(context: &Context, ticket: &Ticket) -> Result<()> {
     let progress = ProgressEmitter::new(0, ReceiveProgress::max_blob_progress());
     spawn_progress_proxy(context.clone(), progress.subscribe());
-    let mut connected = false;
     let on_connected = || {
         context.emit_event(ReceiveProgress::Connected.into());
-        connected = true;
+        async { Ok(()) }
+    };
+    let on_collection = |collection: &Collection| {
+        context.emit_event(ReceiveProgress::CollectionReceived.into());
+        progress.set_total(collection.total_blobs_size());
         async { Ok(()) }
     };
     let jobs = Mutex::new(JoinSet::default());
     let on_blob =
         |hash, reader, name| on_blob(context, &progress, &jobs, ticket, hash, reader, name);
-    let res = iroh::get::run(
-        ticket.hash,
-        ticket.token,
-        opts,
+
+    // Perform the transfer.
+    let keylog = false; // Do not enable rustls SSLKEYLOGFILE env var functionality
+    let stats = iroh::get::run_ticket(
+        ticket,
+        keylog,
+        MAX_CONCURRENT_DIALS,
         on_connected,
-        |collection| {
-            context.emit_event(ReceiveProgress::CollectionReceived.into());
-            progress.set_total(collection.total_blobs_size());
-            async { Ok(()) }
-        },
+        on_collection,
         on_blob,
     )
-    .await;
+    .await?;
 
     let mut jobs = jobs.lock().await;
     while let Some(job) = jobs.join_next().await {
-        job.context("job failed").map_err(TransferError::Other)?;
+        job.context("job failed")?;
     }
-
     drop(progress);
-    match res {
-        Ok(stats) => {
-            info!(
-                context,
-                "Backup transfer finished, transfer rate is {} Mbps.",
-                stats.mbits()
-            );
-            Ok(())
-        }
-        Err(err) => match connected {
-            true => Err(TransferError::Other(err)),
-            false => Err(TransferError::ConnectionError(err)),
-        },
-    }
+    info!(
+        context,
+        "Backup transfer finished, transfer rate was {} Mbps.",
+        stats.mbits()
+    );
+    Ok(())
 }
 
 /// Get callback when a blob is received from the provider.
@@ -508,7 +497,7 @@ async fn on_blob(
         let context_dir = context
             .get_blobdir()
             .parent()
-            .ok_or(anyhow!("Context dir not found"))?;
+            .ok_or_else(|| 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?;
@@ -529,7 +518,7 @@ async fn on_blob(
 
     if name.starts_with("db/") {
         let context = context.clone();
-        let token = ticket.token.to_string();
+        let token = ticket.token().to_string();
         jobs.lock().await.spawn(async move {
             if let Err(err) = context.sql.import(&path, token).await {
                 error!(context, "cannot import database: {:#?}", err);
@@ -691,4 +680,16 @@ mod tests {
             assert_eq!(out, EventType::ImexProgress(progress));
         }
     }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_drop_provider() {
+        let mut tcm = TestContextManager::new();
+        let ctx = tcm.alice().await;
+
+        let provider = BackupProvider::prepare(&ctx).await.unwrap();
+        drop(provider);
+        ctx.evtracker
+            .get_matching(|ev| matches!(ev, EventType::ImexProgress(0)))
+            .await;
+    }
 }

src/job.rs

@@ -99,7 +99,7 @@ impl Job {
         if self.job_id != 0 {
             context
                 .sql
-                .execute("DELETE FROM jobs WHERE id=?;", paramsv![self.job_id as i32])
+                .execute("DELETE FROM jobs WHERE id=?;", (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?;
         }
 
@@ -153,7 +153,7 @@ impl<'a> Connection<'a> {
 }
 
 pub(crate) async fn perform_job(context: &Context, mut connection: Connection<'_>, mut job: Job) {
-    info!(context, "job {} started...", &job);
+    info!(context, "Job {} started...", &job);
 
     let try_res = match perform_job_action(context, &mut job, &mut connection, 0).await {
         Status::RetryNow => perform_job_action(context, &mut job, &mut connection, 1).await,
@@ -165,7 +165,7 @@ pub(crate) async fn perform_job(context: &Context, mut connection: Connection<'_
             let tries = job.tries + 1;
 
             if tries < JOB_RETRIES {
-                info!(context, "increase job {} tries to {}", job, tries);
+                info!(context, "Increase job {job} tries to {tries}.");
                 job.tries = tries;
                 let time_offset = get_backoff_time_offset(tries);
                 job.desired_timestamp = time() + time_offset;
@@ -177,26 +177,23 @@ pub(crate) async fn perform_job(context: &Context, mut connection: Connection<'_
                     time_offset
                 );
                 job.save(context).await.unwrap_or_else(|err| {
-                    error!(context, "failed to save job: {:#}", err);
+                    error!(context, "Failed to save job: {err:#}.");
                 });
             } else {
                 info!(
                     context,
-                    "remove job {} as it exhausted {} retries", job, JOB_RETRIES
+                    "Remove job {job} as it exhausted {JOB_RETRIES} retries."
                 );
                 job.delete(context).await.unwrap_or_else(|err| {
-                    error!(context, "failed to delete job: {:#}", err);
+                    error!(context, "Failed to delete job: {err:#}.");
                 });
             }
         }
         Status::Finished(res) => {
             if let Err(err) = res {
-                warn!(
-                    context,
-                    "remove job {} as it failed with error {:#}", job, err
-                );
+                warn!(context, "Remove job {job} as it failed with error {err:#}.");
             } else {
-                info!(context, "remove job {} as it succeeded", job);
+                info!(context, "Remove job {job} as it succeeded.");
             }
 
             job.delete(context).await.unwrap_or_else(|err| {
@@ -212,13 +209,13 @@ async fn perform_job_action(
     connection: &mut Connection<'_>,
     tries: u32,
 ) -> Status {
-    info!(context, "begin immediate try {} of job {}", tries, job);
+    info!(context, "Begin immediate try {tries} of job {job}.");
 
     let try_res = match job.action {
         Action::DownloadMsg => job.download_msg(context, connection.inbox()).await,
     };
 
-    info!(context, "Finished immediate try {} of job {}", tries, job);
+    info!(context, "Finished immediate try {tries} of job {job}.");
 
     try_res
 }
@@ -250,7 +247,7 @@ pub(crate) async fn schedule_resync(context: &Context) -> Result<()> {
 pub async fn add(context: &Context, job: Job) -> Result<()> {
     job.save(context).await.context("failed to save job")?;
 
-    info!(context, "interrupt: imap");
+    info!(context, "Interrupt: IMAP.");
     context
         .scheduler
         .interrupt_inbox(InterruptInfo::new(false))
@@ -264,7 +261,7 @@ pub async fn add(context: &Context, job: Job) -> Result<()> {
 /// jobs, this is tricky and probably wrong currently. Look at the
 /// SQL queries for details.
 pub(crate) async fn load_next(context: &Context, info: &InterruptInfo) -> Result<Option<Job>> {
-    info!(context, "loading job");
+    info!(context, "Loading job.");
 
     let query;
     let params;
@@ -280,7 +277,7 @@ WHERE desired_timestamp<=?
 ORDER BY action DESC, added_timestamp
 LIMIT 1;
 "#;
-        params = paramsv![t];
+        params = vec![t];
     } else {
         // processing after call to dc_maybe_network():
         // process _all_ pending jobs that failed before
@@ -292,13 +289,13 @@ WHERE tries>0
 ORDER BY desired_timestamp, action DESC
 LIMIT 1;
 "#;
-        params = paramsv![];
+        params = vec![];
     };
 
     loop {
         let job_res = context
             .sql
-            .query_row_optional(query, params.clone(), |row| {
+            .query_row_optional(query, rusqlite::params_from_iter(params.clone()), |row| {
                 let job = Job {
                     job_id: row.get("id")?,
                     action: row.get("action")?,
@@ -316,19 +313,21 @@ LIMIT 1;
             Ok(job) => return Ok(job),
             Err(err) => {
                 // Remove invalid job from the DB
-                info!(context, "cleaning up job, because of {:#}", err);
+                info!(context, "Cleaning up job, because of {err:#}.");
 
                 // TODO: improve by only doing a single query
                 let id = context
                     .sql
-                    .query_row(query, params.clone(), |row| row.get::<_, i32>(0))
+                    .query_row(query, rusqlite::params_from_iter(params.clone()), |row| {
+                        row.get::<_, i32>(0)
+                    })
                     .await
-                    .context("Failed to retrieve invalid job ID from the database")?;
+                    .context("failed to retrieve invalid job ID from the database")?;
                 context
                     .sql
-                    .execute("DELETE FROM jobs WHERE id=?;", paramsv![id])
+                    .execute("DELETE FROM jobs WHERE id=?;", (id,))
                     .await
-                    .with_context(|| format!("Failed to delete invalid job {id}"))?;
+                    .with_context(|| format!("failed to delete invalid job {id}"))?;
             }
         }
     }
@@ -347,7 +346,7 @@ mod tests {
                 "INSERT INTO jobs
                    (added_timestamp, action, foreign_id, desired_timestamp)
                  VALUES (?, ?, ?, ?);",
-                paramsv![
+                (
                     now,
                     if valid {
                         Action::DownloadMsg as i32
@@ -355,8 +354,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;
                     "#,
-                    paramsv![addr],
+                    (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;
         "#,
-            paramsv![addr],
+            (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=?;",
-                    paramsv![public_key, secret_key],
+                    (&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 (?,?,?,?,?);",
-                    paramsv![addr, is_default, public_key, secret_key, t],
+                    (addr, is_default, &public_key, &secret_key, t),
                 )
                 .context("failed to insert keypair")?;
 

src/lib.rs

@@ -35,11 +35,6 @@ 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;
 
@@ -71,6 +66,7 @@ pub mod ephemeral;
 mod http;
 mod imap;
 pub mod imex;
+pub mod release;
 mod scheduler;
 #[macro_use]
 mod job;

src/location.rs

@@ -5,7 +5,6 @@ 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;
 
@@ -78,16 +77,15 @@ pub struct Kml {
     pub curr: Location,
 }
 
-bitflags! {
-    #[derive(Default)]
-    struct KmlTag: i32 {
-        const UNDEFINED = 0x00;
-        const PLACEMARK = 0x01;
-        const TIMESTAMP = 0x02;
-        const WHEN = 0x04;
-        const POINT = 0x08;
-        const COORDINATES = 0x10;
-    }
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+enum KmlTag {
+    #[default]
+    Undefined,
+    Placemark,
+    PlacemarkTimestamp,
+    PlacemarkTimestampWhen,
+    PlacemarkPoint,
+    PlacemarkPointCoordinates,
 }
 
 impl Kml {
@@ -128,12 +126,14 @@ impl Kml {
     }
 
     fn text_cb(&mut self, event: &BytesText) {
-        if self.tag.contains(KmlTag::WHEN) || self.tag.contains(KmlTag::COORDINATES) {
+        if self.tag == KmlTag::PlacemarkTimestampWhen
+            || self.tag == KmlTag::PlacemarkPointCoordinates
+        {
             let val = event.unescape().unwrap_or_default();
 
             let val = val.replace(['\n', '\r', '\t', ' '], "");
 
-            if self.tag.contains(KmlTag::WHEN) && val.len() >= 19 {
+            if self.tag == KmlTag::PlacemarkTimestampWhen && 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.contains(KmlTag::COORDINATES) {
+            } else if self.tag == KmlTag::PlacemarkPointCoordinates {
                 let parts = val.splitn(2, ',').collect::<Vec<_>>();
                 if let [longitude, latitude] = &parts[..] {
                     self.curr.longitude = longitude.parse().unwrap_or_default();
@@ -162,17 +162,41 @@ impl Kml {
             .trim()
             .to_lowercase();
 
-        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()));
+        match self.tag {
+            KmlTag::PlacemarkTimestampWhen => {
+                if tag == "when" {
+                    self.tag = KmlTag::PlacemarkTimestamp
+                }
             }
-            self.tag = KmlTag::UNDEFINED;
-        };
+            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 => {}
+        }
     }
 
     fn starttag_cb<B: std::io::BufRead>(
@@ -196,19 +220,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.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;
+        } 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;
             if let Some(acc) = event.attributes().find(|attr| {
                 attr.as_ref()
                     .map(|a| {
@@ -247,11 +271,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 {
@@ -286,7 +310,7 @@ pub async fn is_sending_locations_to_chat(
                 .sql
                 .exists(
                     "SELECT COUNT(id) FROM chats  WHERE id=?  AND locations_send_until>?;",
-                    paramsv![chat_id, time()],
+                    (chat_id, time()),
                 )
                 .await?
         }
@@ -295,7 +319,7 @@ pub async fn is_sending_locations_to_chat(
                 .sql
                 .exists(
                     "SELECT COUNT(id) FROM chats  WHERE locations_send_until>?;",
-                    paramsv![time()],
+                    (time(),),
                 )
                 .await?
         }
@@ -314,7 +338,7 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
         .sql
         .query_map(
             "SELECT id FROM chats WHERE locations_send_until>?;",
-            paramsv![time()],
+            (time(),),
             |row| row.get::<_, i32>(0),
             |chats| {
                 chats
@@ -328,14 +352,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 {
@@ -380,14 +404,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)?;
@@ -447,7 +471,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=?;",
-        paramsv![chat_id], |row| {
+        (chat_id,), |row| {
             let send_begin: i64 = row.get(0)?;
             let send_until: i64 = row.get(1)?;
             let last_sent: i64 = row.get(2)?;
@@ -476,12 +500,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)?;
@@ -551,7 +575,7 @@ pub async fn set_kml_sent_timestamp(
         .sql
         .execute(
             "UPDATE chats SET locations_last_sent=? WHERE id=?;",
-            paramsv![timestamp, chat_id],
+            (timestamp, chat_id),
         )
         .await?;
     Ok(())
@@ -563,7 +587,7 @@ pub async fn set_msg_location_id(context: &Context, msg_id: MsgId, location_id:
         .sql
         .execute(
             "UPDATE msgs SET location_id=? WHERE id=?;",
-            paramsv![location_id, msg_id],
+            (location_id, msg_id),
         )
         .await?;
 
@@ -605,10 +629,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(paramsv![timestamp, contact_id])?;
+                let exists = stmt_test.exists((timestamp, contact_id))?;
 
                 if independent || !exists {
-                    stmt_insert.execute(paramsv![
+                    stmt_insert.execute((
                         timestamp,
                         contact_id,
                         chat_id,
@@ -616,7 +640,7 @@ pub(crate) async fn save(
                         longitude,
                         accuracy,
                         independent,
-                    ])?;
+                    ))?;
 
                     if timestamp > newest_timestamp {
                         // okay to drop, as we use cached prepared statements
@@ -705,7 +729,7 @@ async fn maybe_send_locations(context: &Context) -> Result<Option<u64>> {
      AND timestamp>=? \
      AND timestamp>? \
      AND independent=0",
-                    paramsv![ContactId::SELF, locations_send_begin, locations_last_sent,],
+                    (ContactId::SELF, locations_send_begin, locations_last_sent),
                 )
                 .await?;
 
@@ -757,7 +781,7 @@ async fn maybe_send_locations(context: &Context) -> Result<Option<u64>> {
                     "UPDATE chats \
                          SET locations_send_begin=0, locations_send_until=0 \
                          WHERE id=?",
-                    paramsv![chat_id],
+                    (chat_id,),
                 )
                 .await
                 .context("failed to disable location streaming")?;

src/log.rs

@@ -65,9 +65,6 @@ 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)
@@ -76,73 +73,23 @@ 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, 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()
-    }
+    fn log_err(self, context: &Context) -> Result<T, E>;
 }
 
 impl<T, E: std::fmt::Display> LogExt<T, E> for Result<T, E> {
     #[track_caller]
-    fn log_err_inner(self, context: &Context, msg: Option<&str>) -> Result<T, E> {
+    fn log_err(self, context: &Context) -> 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}: {msg}{separator}{e:#}",
+                "{file}:{line}: {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,7 +5,6 @@ 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};
@@ -29,8 +28,8 @@ use crate::sql;
 use crate::stock_str;
 use crate::summary::Summary;
 use crate::tools::{
-    create_smeared_timestamp, get_filebytes, get_filemeta, gm2local_offset, read_file, time,
-    timestamp_to_str, truncate,
+    buf_compress, buf_decompress, create_smeared_timestamp, get_filebytes, get_filemeta,
+    gm2local_offset, read_file, time, timestamp_to_str, truncate,
 };
 
 /// Message ID, including reserved IDs.
@@ -78,7 +77,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=?", paramsv![self])
+            .query_get_value("SELECT state FROM msgs WHERE id=?", (self,))
             .await?
             .unwrap_or_default();
         Ok(result)
@@ -107,7 +106,7 @@ SET
   param='' 
 WHERE id=?;
 "#,
-                paramsv![chat_id, self],
+                (chat_id, self),
             )
             .await?;
 
@@ -120,22 +119,19 @@ WHERE id=?;
         // sure they are not left while the message is deleted.
         context
             .sql
-            .execute("DELETE FROM smtp WHERE msg_id=?", paramsv![self])
+            .execute("DELETE FROM smtp WHERE msg_id=?", (self,))
             .await?;
         context
             .sql
-            .execute("DELETE FROM msgs_mdns WHERE msg_id=?;", paramsv![self])
+            .execute("DELETE FROM msgs_mdns WHERE msg_id=?;", (self,))
             .await?;
         context
             .sql
-            .execute(
-                "DELETE FROM msgs_status_updates WHERE msg_id=?;",
-                paramsv![self],
-            )
+            .execute("DELETE FROM msgs_status_updates WHERE msg_id=?;", (self,))
             .await?;
         context
             .sql
-            .execute("DELETE FROM msgs WHERE id=?;", paramsv![self])
+            .execute("DELETE FROM msgs WHERE id=?;", (self,))
             .await?;
         Ok(())
     }
@@ -144,7 +140,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=?", paramsv![self])
+            .query_get_value("SELECT chat_id FROM msgs WHERE id=?", (self,))
             .await?
             .unwrap_or_default();
         context.emit_event(EventType::MsgDelivered {
@@ -329,7 +325,7 @@ impl Message {
                     " FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id",
                     " WHERE m.id=?;"
                 ),
-                paramsv![id],
+                (id,),
                 |row| {
                     let text = match row.get_ref("txt")? {
                         rusqlite::types::ValueRef::Text(buf) => {
@@ -950,7 +946,7 @@ impl Message {
             .sql
             .execute(
                 "UPDATE msgs SET param=? WHERE id=?;",
-                paramsv![self.param.to_string(), self.id],
+                (self.param.to_string(), self.id),
             )
             .await?;
         Ok(())
@@ -961,7 +957,7 @@ impl Message {
             .sql
             .execute(
                 "UPDATE msgs SET subject=? WHERE id=?;",
-                paramsv![self.subject, self.id],
+                (&self.subject, self.id),
             )
             .await?;
         Ok(())
@@ -1095,7 +1091,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=?;", paramsv![msg_id])
+        .query_get_value("SELECT txt_raw FROM msgs WHERE id=?;", (msg_id,))
         .await?;
 
     let mut ret = String::new();
@@ -1145,7 +1141,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=?;",
-            paramsv![msg_id],
+            (msg_id,),
             |row| {
                 let contact_id: ContactId = row.get(0)?;
                 let ts: i64 = row.get(1)?;
@@ -1226,7 +1222,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=?",
-                paramsv![msg.rfc724_mid],
+                (msg.rfc724_mid,),
                 |row| {
                     let folder: String = row.get("folder")?;
                     let uid: u32 = row.get("uid")?;
@@ -1246,7 +1242,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=?;", paramsv![msg_id])
+        .query_get_value("SELECT hop_info FROM msgs WHERE id=?;", (msg_id,))
         .await?;
 
     ret += "\n\n";
@@ -1350,21 +1346,52 @@ 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 = context
+    let (headers, compressed) = context
         .sql
         .query_row(
-            "SELECT mime_headers FROM msgs WHERE id=?;",
-            paramsv![msg_id],
+            "SELECT mime_headers, mime_compressed FROM msgs WHERE id=?",
+            (msg_id,),
             |row| {
-                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),
-                })
+                let headers = sql::row_get_vec(row, 0)?;
+                let compressed: bool = row.get(1)?;
+                Ok((headers, compressed))
             },
         )
         .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)
 }
 
@@ -1391,14 +1418,14 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
             .sql
             .execute(
                 "UPDATE imap SET target=? WHERE rfc724_mid=?",
-                paramsv![target, msg.rfc724_mid],
+                (target, msg.rfc724_mid),
             )
             .await?;
 
         let logging_xdc_id = context
             .debug_logging
             .read()
-            .await
+            .expect("RwLock is poisoned")
             .as_ref()
             .map(|dl| dl.msg_id);
 
@@ -1413,8 +1440,6 @@ 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?;
     }
 
@@ -1431,7 +1456,7 @@ async fn delete_poi_location(context: &Context, location_id: u32) -> Result<()>
         .sql
         .execute(
             "DELETE FROM locations WHERE independent = 1 AND id=?;",
-            paramsv![location_id as i32],
+            (location_id as i32,),
         )
         .await?;
     Ok(())
@@ -1443,6 +1468,12 @@ 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(
@@ -1530,7 +1561,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(?, ?, ?)",
-                            paramsv![id, curr_from_id, curr_rfc724_mid],
+                            (id, curr_from_id, curr_rfc724_mid),
                         )
                         .await
                         .context("failed to insert into smtp_mdns")?;
@@ -1558,10 +1589,7 @@ pub(crate) async fn update_msg_state(
 ) -> Result<()> {
     context
         .sql
-        .execute(
-            "UPDATE msgs SET state=? WHERE id=?;",
-            paramsv![state, msg_id],
-        )
+        .execute("UPDATE msgs SET state=? WHERE id=?;", (state, msg_id))
         .await?;
     Ok(())
 }
@@ -1581,7 +1609,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=?;", paramsv![msg_id])
+        .query_get_value("SELECT chat_id FROM msgs WHERE id=?;", (msg_id,))
         .await?;
 
     if let Some(chat_id) = chat_id {
@@ -1607,7 +1635,7 @@ pub(crate) async fn set_msg_failed(context: &Context, msg_id: MsgId, error: &str
             .sql
             .execute(
                 "UPDATE msgs SET state=?, error=? WHERE id=?;",
-                paramsv![msg.state, error, msg_id],
+                (msg.state, error, msg_id),
             )
             .await
         {
@@ -1652,7 +1680,7 @@ pub async fn handle_mdn(
                 " WHERE rfc724_mid=? AND from_id=1",
                 " ORDER BY m.id;"
             ),
-            paramsv![rfc724_mid],
+            (&rfc724_mid,),
             |row| {
                 Ok((
                     row.get::<_, MsgId>("msg_id")?,
@@ -1678,7 +1706,7 @@ pub async fn handle_mdn(
         .sql
         .exists(
             "SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=? AND contact_id=?;",
-            paramsv![msg_id, from_id],
+            (msg_id, from_id),
         )
         .await?
     {
@@ -1686,7 +1714,7 @@ pub async fn handle_mdn(
             .sql
             .execute(
                 "INSERT INTO msgs_mdns (msg_id, contact_id, timestamp_sent) VALUES (?, ?, ?);",
-                paramsv![msg_id, from_id, timestamp_sent],
+                (msg_id, from_id, timestamp_sent),
             )
             .await?;
     }
@@ -1726,7 +1754,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",
             ),
-            paramsv![failed.rfc724_mid],
+            (&failed.rfc724_mid,),
             |row| {
                 Ok((
                     row.get::<_, MsgId>("msg_id")?,
@@ -1866,7 +1894,7 @@ pub async fn estimate_deletion_cnt(
                AND timestamp < ?
                AND chat_id != ?
                AND EXISTS (SELECT * FROM imap WHERE rfc724_mid=m.rfc724_mid);",
-                paramsv![DC_MSG_ID_LAST_SPECIAL, threshold_timestamp, self_chat_id],
+                (DC_MSG_ID_LAST_SPECIAL, threshold_timestamp, self_chat_id),
             )
             .await?
     } else {
@@ -1879,12 +1907,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?
     };
@@ -1905,7 +1933,7 @@ pub(crate) async fn rfc724_mid_exists(
         .sql
         .query_row_optional(
             "SELECT id FROM msgs WHERE rfc724_mid=?",
-            paramsv![rfc724_mid],
+            (rfc724_mid,),
             |row| {
                 let msg_id: MsgId = row.get(0)?;
 

src/mimefactory.rs

@@ -27,16 +27,13 @@ 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, get_filebytes, remove_subject_prefix,
-    time,
+    create_outgoing_rfc724_mid, create_smeared_timestamp, 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 {
@@ -169,7 +166,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;",
-                    paramsv![msg.chat_id],
+                    (msg.chat_id,),
                     |row| {
                         let authname: String = row.get(0)?;
                         let addr: String = row.get(1)?;
@@ -198,7 +195,7 @@ impl<'a> MimeFactory<'a> {
             .sql
             .query_row(
                 "SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?",
-                paramsv![msg.id],
+                (msg.id,),
                 |row| {
                     let in_reply_to: String = row.get(0)?;
                     let references: String = row.get(1)?;
@@ -1211,15 +1208,8 @@ impl<'a> MimeFactory<'a> {
 
         // add attachment part
         if self.msg.viewtype.has_file() {
-            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);
-            }
+            let (file_part, _) = build_body_file(context, self.msg, "").await?;
+            parts.push(file_part);
         }
 
         if let Some(meta_part) = meta_part {
@@ -1483,16 +1473,6 @@ 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, truncate_by_lines};
+use crate::tools::{get_filemeta, parse_receive_headers, strip_rtlo_characters, truncate_by_lines};
 use crate::{location, tools};
 
 /// A parsed MIME message.
@@ -90,6 +90,9 @@ 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;
@@ -1059,6 +1062,7 @@ impl MimeMessage {
                             }
                         };
 
+                        let is_plaintext = mime_type == mime::TEXT_PLAIN;
                         let mut dehtml_failed = false;
 
                         let SimplifiedText {
@@ -1139,7 +1143,9 @@ impl MimeMessage {
                             self.is_forwarded = true;
                         }
 
-                        self.footer = footer;
+                        if self.footer.is_none() && is_plaintext {
+                            self.footer = Some(footer.unwrap_or_default());
+                        }
                     }
                     _ => {}
                 }
@@ -1283,7 +1289,7 @@ impl MimeMessage {
         if !key.details.users.iter().any(|user| {
             user.id
                 .id()
-                .ends_with(&(String::from("<") + &peerstate.addr + ">"))
+                .ends_with((String::from("<") + &peerstate.addr + ">").as_bytes())
         }) {
             return Ok(false);
         }
@@ -1668,10 +1674,7 @@ impl MimeMessage {
         {
             context
                 .sql
-                .query_get_value(
-                    "SELECT timestamp FROM msgs WHERE rfc724_mid=?",
-                    paramsv![field],
-                )
+                .query_get_value("SELECT timestamp FROM msgs WHERE rfc724_mid=?", (field,))
                 .await?
         } else {
             None
@@ -1952,6 +1955,8 @@ fn get_attachment_filename(
         };
     }
 
+    let desired_filename = desired_filename.map(|filename| strip_rtlo_characters(&filename));
+
     Ok(desired_filename)
 }
 
@@ -1976,10 +1981,10 @@ pub(crate) fn get_list_post(headers: &[MailHeader]) -> Option<String> {
         .map(|s| s.addr)
 }
 
-fn get_all_addresses_from_header<F>(headers: &[MailHeader], pred: F) -> Vec<SingleInfo>
-where
-    F: Fn(String) -> bool,
-{
+fn get_all_addresses_from_header(
+    headers: &[MailHeader],
+    pred: fn(String) -> bool,
+) -> Vec<SingleInfo> {
     let mut result: Vec<SingleInfo> = Default::default();
 
     headers
@@ -2350,7 +2355,7 @@ mod tests {
             .sql
             .execute(
                 "INSERT INTO msgs (rfc724_mid, timestamp) VALUES(?,?)",
-                paramsv!["Gr.beZgAF2Nn0-.oyaJOpeuT70@example.org", timestamp],
+                ("Gr.beZgAF2Nn0-.oyaJOpeuT70@example.org", timestamp),
             )
             .await
             .expect("Failed to write to the database");

src/net.rs

@@ -75,7 +75,7 @@ async fn lookup_host_with_cache(
                  VALUES (?, ?, ?)
                  ON CONFLICT (hostname, address)
                  DO UPDATE SET timestamp=excluded.timestamp",
-                paramsv![hostname, ip_string, now],
+                (hostname, ip_string, now),
             )
             .await?;
     }
@@ -89,7 +89,7 @@ async fn lookup_host_with_cache(
                  WHERE hostname = ?
                  AND ? < timestamp + 30 * 24 * 3600
                  ORDER BY timestamp DESC",
-                paramsv![hostname, now],
+                (hostname, now),
                 |row| {
                     let address: String = row.get(0)?;
                     Ok(address)
@@ -157,7 +157,7 @@ pub(crate) async fn connect_tcp(
                         "UPDATE dns_cache
                          SET timestamp = ?
                          WHERE address = ?",
-                        paramsv![time(), resolved_addr.ip().to_string()],
+                        (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, paramsv![addr]).await
+        Self::from_stmt(context, query, (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, paramsv![fp, fp, fp]).await
+        Self::from_stmt(context, query, (&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, paramsv![fp, addr, fp]).await
+        Self::from_stmt(context, query, (&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;",
-                paramsv![self.addr],
+                (&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=?;",
-                        paramsv![chat_id],
+                        (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(?)", paramsv![addr])
+            .execute("INSERT INTO acpeerstates (addr) VALUES(?)", (addr,))
             .await
             .expect("Failed to write to the database");
 

src/pgp.rs

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

src/provider.rs

@@ -3,12 +3,11 @@
 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, PROVIDER_UPDATED};
+use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS};
 
 /// Provider status according to manual testing.
 #[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
@@ -258,22 +257,12 @@ 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() {
@@ -336,18 +325,6 @@ 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::{self, get_chat_id_by_grpid, ChatIdBlocked};
+use crate::chat::{get_chat_id_by_grpid, ChatIdBlocked};
 use crate::config::Config;
 use crate::constants::Blocked;
 use crate::contact::{
@@ -21,7 +21,6 @@ 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
@@ -435,16 +434,9 @@ 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")?;
-            let chat = ChatIdBlocked::get_for_contact(context, contact_id, Blocked::Request)
+            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)
@@ -508,7 +500,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(anyhow!("invalid DCBACKUP scheme"))?;
+        .ok_or_else(|| 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",
-                paramsv![msg_id, contact_id],
+                (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",
-                paramsv![msg_id, contact_id, reaction.as_str()],
+                (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=?",
-            paramsv![msg_id, ContactId::SELF],
+            (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=?",
-            paramsv![msg_id],
+            (msg_id,),
             |row| {
                 let contact_id: ContactId = row.get(0)?;
                 let reaction: String = row.get(1)?;
@@ -287,12 +287,14 @@ 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() {
@@ -550,4 +552,40 @@ 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,7 +37,9 @@ 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::{extract_grpid_from_rfc724_mid, smeared_time};
+use crate::tools::{
+    buf_compress, extract_grpid_from_rfc724_mid, smeared_time, strip_rtlo_characters,
+};
 use crate::{contact, imap};
 
 /// This is the struct that is returned after receiving one email (aka MIME message).
@@ -96,7 +98,7 @@ pub(crate) async fn receive_imf_inner(
     is_partial_download: Option<u32>,
     fetching_existing_messages: bool,
 ) -> Result<Option<ReceivedMsg>> {
-    info!(context, "Receiving message, seen={}...", seen);
+    info!(context, "Receiving message, seen={seen}...");
 
     if std::env::var(crate::DCC_MIME_DEBUG).is_ok() {
         info!(
@@ -109,14 +111,14 @@ pub(crate) async fn receive_imf_inner(
     let mut mime_parser = match MimeMessage::from_bytes(context, imf_raw, is_partial_download).await
     {
         Err(err) => {
-            warn!(context, "receive_imf: can't parse MIME: {:#}", err);
+            warn!(context, "receive_imf: can't parse MIME: {err:#}.");
             let msg_ids;
             if !rfc724_mid.starts_with(GENERATED_PREFIX) {
                 let row_id = context
                     .sql
                     .execute(
                         "INSERT INTO msgs(rfc724_mid, chat_id) VALUES (?,?)",
-                        paramsv![rfc724_mid, DC_CHAT_ID_TRASH],
+                        (rfc724_mid, DC_CHAT_ID_TRASH),
                     )
                     .await?;
                 msg_ids = vec![MsgId::new(u32::try_from(row_id)?)];
@@ -138,11 +140,11 @@ pub(crate) async fn receive_imf_inner(
 
     // we can not add even an empty record if we have no info whatsoever
     if !mime_parser.has_headers() {
-        warn!(context, "receive_imf: no headers found");
+        warn!(context, "receive_imf: no headers found.");
         return Ok(None);
     }
 
-    info!(context, "received message has Message-Id: {}", rfc724_mid);
+    info!(context, "Received message has Message-Id: {rfc724_mid}");
 
     // check, if the mail is already in our database.
     // make sure, this check is done eg. before securejoin-processing.
@@ -182,7 +184,7 @@ pub(crate) async fn receive_imf_inner(
             None => {
                 warn!(
                     context,
-                    "receive_imf: From field does not contain an acceptable address"
+                    "receive_imf: From field does not contain an acceptable address."
                 );
                 return Ok(None);
             }
@@ -269,13 +271,13 @@ pub(crate) async fn receive_imf_inner(
         if from_id == ContactId::SELF {
             if mime_parser.was_encrypted() {
                 if let Err(err) = context.execute_sync_items(sync_items).await {
-                    warn!(context, "receive_imf cannot execute sync items: {:#}", err);
+                    warn!(context, "receive_imf cannot execute sync items: {err:#}.");
                 }
             } else {
-                warn!(context, "sync items are not encrypted.");
+                warn!(context, "Sync items are not encrypted.");
             }
         } else {
-            warn!(context, "sync items not sent by self.");
+            warn!(context, "Sync items not sent by self.");
         }
     }
 
@@ -284,7 +286,7 @@ pub(crate) async fn receive_imf_inner(
             .receive_status_update(from_id, insert_msg_id, status_update)
             .await
         {
-            warn!(context, "receive_imf cannot update status: {:#}", err);
+            warn!(context, "receive_imf cannot update status: {err:#}.");
         }
     }
 
@@ -302,36 +304,30 @@ pub(crate) async fn receive_imf_inner(
             )
             .await
             {
-                warn!(
-                    context,
-                    "receive_imf cannot update profile image: {:#}", err
-                );
+                warn!(context, "receive_imf cannot update profile image: {err:#}.");
             };
         }
     }
 
-    // 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 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 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?
         {
-            warn!(context, "cannot update contact status: {:#}", err);
+            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:#}.");
+            }
         }
     }
 
@@ -347,7 +343,7 @@ pub(crate) async fn receive_imf_inner(
                 .sql
                 .execute(
                     "UPDATE imap SET target=? WHERE rfc724_mid=?",
-                    paramsv![target, rfc724_mid],
+                    (target, rfc724_mid),
                 )
                 .await?;
         } else if !mime_parser.mdn_reports.is_empty() && mime_parser.has_chat_version() {
@@ -364,6 +360,7 @@ 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)
@@ -394,7 +391,7 @@ pub async fn from_field_to_contact_id(
         Err(err) => {
             warn!(
                 context,
-                "Cannot create a contact for the given From field: {:#}.", err
+                "Cannot create a contact for the given From field: {err:#}."
             );
             return Ok(None);
         }
@@ -476,7 +473,7 @@ async fn add_parts(
         // this message is a classic email not a chat-message nor a reply to one
         match show_emails {
             ShowEmails::Off => {
-                info!(context, "Classical email not shown (TRASH)");
+                info!(context, "Classical email not shown (TRASH).");
                 chat_id = Some(DC_CHAT_ID_TRASH);
                 allow_creation = false;
             }
@@ -519,7 +516,7 @@ async fn add_parts(
                     securejoin_seen = false;
                 }
                 Err(err) => {
-                    warn!(context, "Error in Secure-Join message handling: {:#}", err);
+                    warn!(context, "Error in Secure-Join message handling: {err:#}.");
                     chat_id = Some(DC_CHAT_ID_TRASH);
                     securejoin_seen = true;
                 }
@@ -536,7 +533,8 @@ async fn add_parts(
 
         if chat_id.is_none() && mime_parser.delivery_report.is_some() {
             chat_id = Some(DC_CHAT_ID_TRASH);
-            info!(context, "Message is a DSN (TRASH)",);
+            info!(context, "Message is a DSN (TRASH).",);
+            markseen_on_imap_table(context, rfc724_mid).await.ok();
         }
 
         if chat_id.is_none() {
@@ -553,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,
@@ -581,13 +579,15 @@ 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::Not {
-                    new_chat_id.unblock(context).await?;
-                    chat_id_blocked = Blocked::Not;
-                }
+        // 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;
             }
         }
 
@@ -693,7 +693,8 @@ async fn add_parts(
             } else if allow_creation {
                 if let Ok(chat) = ChatIdBlocked::get_for_contact(context, from_id, create_blocked)
                     .await
-                    .log_err(context, "Failed to get (new) chat for contact")
+                    .context("Failed to get (new) chat for contact")
+                    .log_err(context)
                 {
                     chat_id = Some(chat.id);
                     chat_id_blocked = chat.blocked;
@@ -754,7 +755,7 @@ async fn add_parts(
                     chat_id = None;
                 }
                 Err(err) => {
-                    warn!(context, "Error in Secure-Join watching: {:#}", err);
+                    warn!(context, "Error in Secure-Join watching: {err:#}.");
                     chat_id = Some(DC_CHAT_ID_TRASH);
                 }
             }
@@ -771,7 +772,7 @@ async fn add_parts(
 
         if is_draft {
             // Most mailboxes have a "Drafts" folder where constantly new emails appear but we don't actually want to show them
-            info!(context, "Email is probably just a draft (TRASH)");
+            info!(context, "Email is probably just a draft (TRASH).");
             chat_id = Some(DC_CHAT_ID_TRASH);
         }
 
@@ -845,7 +846,8 @@ async fn add_parts(
             // maybe an Autocrypt Setup Message
             if let Ok(chat) = ChatIdBlocked::get_for_contact(context, ContactId::SELF, Blocked::Not)
                 .await
-                .log_err(context, "Failed to get (new) chat for contact")
+                .context("Failed to get (new) chat for contact")
+                .log_err(context)
             {
                 chat_id = Some(chat.id);
                 chat_id_blocked = chat.blocked;
@@ -863,14 +865,15 @@ async fn add_parts(
     if fetching_existing_messages && mime_parser.decrypting_failed {
         chat_id = Some(DC_CHAT_ID_TRASH);
         // We are only gathering old messages on first start. We do not want to add loads of non-decryptable messages to the chats.
-        info!(context, "Existing non-decipherable message. (TRASH)");
+        info!(context, "Existing non-decipherable message (TRASH).");
     }
 
     if mime_parser.webxdc_status_update.is_some() && mime_parser.parts.len() == 1 {
         if let Some(part) = mime_parser.parts.first() {
             if part.typ == Viewtype::Text && part.msg.is_empty() {
                 chat_id = Some(DC_CHAT_ID_TRASH);
-                info!(context, "Message is a status update only (TRASH)");
+                info!(context, "Message is a status update only (TRASH).");
+                markseen_on_imap_table(context, rfc724_mid).await.ok();
             }
         }
     }
@@ -880,7 +883,7 @@ async fn add_parts(
         DC_CHAT_ID_TRASH
     } else {
         chat_id.unwrap_or_else(|| {
-            info!(context, "No chat id for message (TRASH)");
+            info!(context, "No chat id for message (TRASH).");
             DC_CHAT_ID_TRASH
         })
     };
@@ -892,10 +895,7 @@ async fn add_parts(
         match value.parse::<EphemeralTimer>() {
             Ok(timer) => timer,
             Err(err) => {
-                warn!(
-                    context,
-                    "can't parse ephemeral timer \"{}\": {:#}", value, err
-                );
+                warn!(context, "Can't parse ephemeral timer \"{value}\": {err:#}.");
                 EphemeralTimer::Disabled
             }
         }
@@ -915,12 +915,7 @@ async fn add_parts(
         && !mime_parser.parts.is_empty()
         && chat_id.get_ephemeral_timer(context).await? != ephemeral_timer
     {
-        info!(
-            context,
-            "received new ephemeral timer value {:?} for chat {}, checking if it should be applied",
-            ephemeral_timer,
-            chat_id
-        );
+        info!(context, "Received new ephemeral timer value {ephemeral_timer:?} for chat {chat_id}, checking if it should be applied.");
         if is_dc_message == MessengerMessage::Yes
             && get_previous_message(context, mime_parser)
                 .await?
@@ -936,9 +931,7 @@ async fn add_parts(
             // have seen or sent ourselves, so we ignore incoming timer to prevent a rollback.
             warn!(
                 context,
-                "ignoring ephemeral timer change to {:?} for chat {} to avoid rollback",
-                ephemeral_timer,
-                chat_id
+                "Ignoring ephemeral timer change to {ephemeral_timer:?} for chat {chat_id} to avoid rollback.",
             );
         } else if chat_id
             .update_timestamp(context, Param::EphemeralSettingsTimestamp, sent_timestamp)
@@ -950,12 +943,12 @@ async fn add_parts(
             {
                 warn!(
                     context,
-                    "failed to modify timer for chat {}: {:#}", chat_id, err
+                    "Failed to modify timer for chat {chat_id}: {err:#}."
                 );
             } else {
                 info!(
                     context,
-                    "updated ephemeral timer to {:?} for chat {}", ephemeral_timer, chat_id
+                    "Updated ephemeral timer to {ephemeral_timer:?} for chat {chat_id}."
                 );
                 if mime_parser.is_system_message != SystemMessage::EphemeralTimerChanged {
                     chat::add_info_msg(
@@ -970,7 +963,7 @@ async fn add_parts(
         } else {
             warn!(
                 context,
-                "ignoring ephemeral timer change to {:?} because it's outdated", ephemeral_timer
+                "Ignoring ephemeral timer change to {ephemeral_timer:?} because it is outdated."
             );
         }
     }
@@ -999,7 +992,7 @@ async fn add_parts(
         if chat.is_protected() || new_status.is_some() {
             if let Err(err) = check_verified_properties(context, mime_parser, from_id, to_ids).await
             {
-                warn!(context, "verification problem: {:#}", err);
+                warn!(context, "Verification problem: {err:#}.");
                 let s = format!("{err}. See 'Info' for more details");
                 mime_parser.repl_msg_by_error(&s);
             } else {
@@ -1074,18 +1067,19 @@ async fn add_parts(
     let mut save_mime_modified = mime_parser.is_mime_modified;
 
     let mime_headers = if save_mime_headers || save_mime_modified {
-        if mime_parser.was_encrypted() && !mime_parser.decoded_data.is_empty() {
+        let headers = 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 &mime_parser.parts {
+    for part in &mut mime_parser.parts {
         if part.is_reaction {
             set_msg_reaction(
                 context,
@@ -1101,6 +1095,7 @@ 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 [
@@ -1161,7 +1156,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_in_reply_to,
+    bytes, mime_headers, mime_compressed, mime_in_reply_to,
     mime_references, mime_modified, error, ephemeral_timer,
     ephemeral_timestamp, download_state, hop_info
   )
@@ -1170,7 +1165,7 @@ INSERT INTO msgs
     ?, ?, ?, ?,
     ?, ?, ?, ?,
     ?, ?, ?, ?,
-    ?, ?, ?, ?,
+    ?, ?, ?, ?, 1,
     ?, ?, ?, ?,
     ?, ?, ?, ?
   )
@@ -1179,7 +1174,8 @@ 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_in_reply_to=excluded.mime_in_reply_to,
+    bytes=excluded.bytes, mime_headers=excluded.mime_headers,
+    mime_compressed=excluded.mime_compressed, 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
 "#)?;
@@ -1369,7 +1365,7 @@ async fn calc_sort_timestamp(
             .sql
             .query_get_value(
                 "SELECT MAX(timestamp) FROM msgs WHERE chat_id=? AND state>?",
-                paramsv![chat_id, MessageState::InFresh],
+                (chat_id, MessageState::InFresh),
             )
             .await?;
 
@@ -1429,7 +1425,7 @@ async fn lookup_chat_by_reply(
 
         info!(
             context,
-            "Assigning message to {} as it's a reply to {}", parent_chat.id, parent.rfc724_mid
+            "Assigning message to {} as it's a reply to {}.", parent_chat.id, parent.rfc724_mid
         );
         return Ok(Some((parent_chat.id, parent_chat.blocked)));
     }
@@ -1499,7 +1495,7 @@ async fn create_or_lookup_group(
             .map(|chat_id| (chat_id, create_blocked));
         return Ok(res);
     } else {
-        info!(context, "creating ad-hoc group prevented from caller");
+        info!(context, "Creating ad-hoc group prevented from caller.");
         return Ok(None);
     };
 
@@ -1525,7 +1521,7 @@ async fn create_or_lookup_group(
 
     let create_protected = if mime_parser.get_header(HeaderDef::ChatVerified).is_some() {
         if let Err(err) = check_verified_properties(context, mime_parser, from_id, to_ids).await {
-            warn!(context, "verification problem: {:#}", err);
+            warn!(context, "Verification problem: {err:#}.");
             let s = format!("{err}. See 'Info' for more details");
             mime_parser.repl_msg_by_error(&s);
         }
@@ -1557,7 +1553,7 @@ async fn create_or_lookup_group(
     {
         // Group does not exist but should be created.
         if !allow_creation {
-            info!(context, "creating group forbidden by caller");
+            info!(context, "Creating group forbidden by caller.");
             return Ok(None);
         }
 
@@ -1618,7 +1614,7 @@ async fn create_or_lookup_group(
     } else {
         // The message was decrypted successfully, but contains a late "quit" or otherwise
         // unwanted message.
-        info!(context, "message belongs to unwanted group (TRASH)");
+        info!(context, "Message belongs to unwanted group (TRASH).");
         Ok(Some((DC_CHAT_ID_TRASH, Blocked::Not)))
     }
 }
@@ -1658,7 +1654,7 @@ async fn apply_group_changes(
                     Some(stock_str::msg_del_member(context, &removed_addr, from_id).await)
                 };
             }
-            None => warn!(context, "removed {:?} has no contact_id", removed_addr),
+            None => warn!(context, "Removed {removed_addr:?} has no contact_id."),
         }
     } else {
         removed_id = None;
@@ -1683,12 +1679,12 @@ async fn apply_group_changes(
                     .update_timestamp(context, Param::GroupNameTimestamp, sent_timestamp)
                     .await?
                 {
-                    info!(context, "updating grpname for chat {}", chat_id);
+                    info!(context, "Updating grpname for chat {chat_id}.");
                     context
                         .sql
                         .execute(
                             "UPDATE chats SET name=? WHERE id=?;",
-                            paramsv![grpname.to_string(), chat_id],
+                            (strip_rtlo_characters(grpname), chat_id),
                         )
                         .await?;
                     send_event_chat_modified = true;
@@ -1723,7 +1719,7 @@ async fn apply_group_changes(
 
     if mime_parser.get_header(HeaderDef::ChatVerified).is_some() {
         if let Err(err) = check_verified_properties(context, mime_parser, from_id, to_ids).await {
-            warn!(context, "verification problem: {:#}", err);
+            warn!(context, "Verification problem: {err:#}.");
             let s = format!("{err}. See 'Info' for more details");
             mime_parser.repl_msg_by_error(&s);
         }
@@ -1743,9 +1739,7 @@ async fn apply_group_changes(
         {
             warn!(
                 context,
-                "Contact {} attempts to modify group chat {} member list without being a member.",
-                from_id,
-                chat_id
+                "Contact {from_id} attempts to modify group chat {chat_id} member list without being a member."
             );
         } else if chat_id
             .update_timestamp(context, Param::MemberListTimestamp, sent_timestamp)
@@ -1760,10 +1754,7 @@ async fn apply_group_changes(
                 // start from scratch.
                 context
                     .sql
-                    .execute(
-                        "DELETE FROM chats_contacts WHERE chat_id=?;",
-                        paramsv![chat_id],
-                    )
+                    .execute("DELETE FROM chats_contacts WHERE chat_id=?;", (chat_id,))
                     .await?;
 
                 members_to_add.push(ContactId::SELF);
@@ -1778,10 +1769,7 @@ async fn apply_group_changes(
             }
             members_to_add.dedup();
 
-            info!(
-                context,
-                "adding {:?} to chat id={}", members_to_add, chat_id
-            );
+            info!(context, "Adding {members_to_add:?} to chat id={chat_id}.");
             chat::add_to_chat_contacts_table(context, chat_id, &members_to_add).await?;
             send_event_chat_modified = true;
         }
@@ -1791,17 +1779,15 @@ async fn apply_group_changes(
         if !chat::is_contact_in_chat(context, chat_id, ContactId::SELF).await? {
             warn!(
                 context,
-                "Received group avatar update for group chat {} we are not a member of.", chat_id
+                "Received group avatar update for group chat {chat_id} we are not a member of."
             );
         } else if !chat::is_contact_in_chat(context, chat_id, from_id).await? {
             warn!(
                 context,
-                "Contact {} attempts to modify group chat {} avatar without being a member.",
-                from_id,
-                chat_id
+                "Contact {from_id} attempts to modify group chat {chat_id} avatar without being a member.",
             );
         } else {
-            info!(context, "group-avatar change for {}", chat_id);
+            info!(context, "Group-avatar change for {chat_id}.");
             if chat
                 .param
                 .update_timestamp(Param::AvatarTimestamp, sent_timestamp)?
@@ -1935,7 +1921,7 @@ async fn create_or_lookup_mailinglist(
         .await
         .with_context(|| {
             format!(
-                "Failed to create mailinglist '{}' for grpid={}",
+                "failed to create mailinglist '{}' for grpid={}",
                 &name, &listid
             )
         })?;
@@ -1943,7 +1929,7 @@ async fn create_or_lookup_mailinglist(
         chat::add_to_chat_contacts_table(context, chat_id, &[ContactId::SELF]).await?;
         Ok(Some((chat_id, blocked)))
     } else {
-        info!(context, "creating list forbidden by caller");
+        info!(context, "Creating list forbidden by caller.");
         Ok(None)
     }
 }
@@ -2035,7 +2021,7 @@ async fn create_adhoc_group(
     if mime_parser.is_mailinglist_message() {
         info!(
             context,
-            "not creating ad-hoc group for mailing list message"
+            "Not creating ad-hoc group for mailing list message."
         );
 
         return Ok(None);
@@ -2052,13 +2038,13 @@ async fn create_adhoc_group(
         // Instead, assign the message to 1:1 chat with the sender.
         warn!(
             context,
-            "not creating ad-hoc group for message that cannot be decrypted"
+            "Not creating ad-hoc group for message that cannot be decrypted."
         );
         return Ok(None);
     }
 
     if member_ids.len() < 3 {
-        info!(context, "not creating ad-hoc group: too few contacts");
+        info!(context, "Not creating ad-hoc group: too few contacts.");
         return Ok(None);
     }
 
@@ -2165,7 +2151,7 @@ async fn check_verified_properties(
     for (to_addr, mut is_verified) in rows {
         info!(
             context,
-            "check_verified_properties: {:?} self={:?}",
+            "check_verified_properties: {:?} self={:?}.",
             to_addr,
             context.is_self_addr(&to_addr).await
         );

src/receive_imf/tests.rs

@@ -367,14 +367,13 @@ 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=?;",
-            paramsv![DC_CHAT_ID_TRASH],
+            (DC_CHAT_ID_TRASH,),
         )
         .await
         .unwrap());
@@ -3046,6 +3045,54 @@ 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

@@ -0,0 +1,10 @@
+//! 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,11 +1,12 @@
 use std::iter::{self, once};
+use std::num::NonZeroUsize;
 use std::sync::atomic::Ordering;
 
-use anyhow::{bail, Context as _, Result};
+use anyhow::{bail, Context as _, Error, Result};
 use async_channel::{self as channel, Receiver, Sender};
 use futures::future::try_join_all;
 use futures_lite::FutureExt;
-use tokio::sync::{RwLock, RwLockWriteGuard};
+use tokio::sync::{oneshot, RwLock, RwLockWriteGuard};
 use tokio::task;
 
 use self::connectivity::ConnectivityStore;
@@ -13,6 +14,7 @@ use crate::config::Config;
 use crate::contact::{ContactId, RecentlySeenLoop};
 use crate::context::Context;
 use crate::ephemeral::{self, delete_expired_imap_messages};
+use crate::events::EventType;
 use crate::imap::{FolderMeaning, Imap};
 use crate::job;
 use crate::location;
@@ -42,24 +44,32 @@ impl SchedulerState {
     /// Whether the scheduler is currently running.
     pub(crate) async fn is_running(&self) -> bool {
         let inner = self.inner.read().await;
-        inner.scheduler.is_some()
+        matches!(*inner, InnerSchedulerState::Started(_))
     }
 
     /// Starts the scheduler if it is not yet started.
     pub(crate) async fn start(&self, context: Context) {
         let mut inner = self.inner.write().await;
-        inner.started = true;
-        if inner.scheduler.is_none() && !inner.paused {
-            Self::do_start(inner, context).await;
+        match *inner {
+            InnerSchedulerState::Started(_) => (),
+            InnerSchedulerState::Stopped => Self::do_start(inner, context).await,
+            InnerSchedulerState::Paused {
+                ref mut started, ..
+            } => *started = true,
         }
     }
 
     /// 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.scheduler = Some(scheduler),
+            Ok(scheduler) => *inner = InnerSchedulerState::Started(scheduler),
             Err(err) => error!(&ctx, "Failed to start IO: {:#}", err),
         }
     }
@@ -67,42 +77,114 @@ 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;
-        inner.started = false;
-        Self::do_stop(inner, context).await;
+        match *inner {
+            InnerSchedulerState::Started(_) => {
+                Self::do_stop(inner, context, InnerSchedulerState::Stopped).await
+            }
+            InnerSchedulerState::Stopped => (),
+            InnerSchedulerState::Paused {
+                ref mut started, ..
+            } => *started = false,
+        }
     }
 
     /// Stops the scheduler if it is currently running.
-    async fn do_stop(mut inner: RwLockWriteGuard<'_, InnerSchedulerState>, context: &Context) {
+    async fn do_stop(
+        mut inner: RwLockWriteGuard<'_, InnerSchedulerState>,
+        context: &Context,
+        new_state: InnerSchedulerState,
+    ) {
         // 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");
-        if let Some(debug_logging) = context.debug_logging.read().await.as_ref() {
+
+        // 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()
+        {
             debug_logging.loop_handle.abort();
         }
-        if let Some(scheduler) = inner.scheduler.take() {
-            scheduler.stop(context).await;
+        let prev_state = std::mem::replace(&mut *inner, new_state);
+        match prev_state {
+            InnerSchedulerState::Started(scheduler) => scheduler.stop(context).await,
+            InnerSchedulerState::Stopped | InnerSchedulerState::Paused { .. } => (),
         }
     }
 
     /// Pauses the IO scheduler.
     ///
-    /// If it is currently running the scheduler will be stopped.  When
-    /// [`IoPausedGuard::resume`] is called the scheduler is started again.
+    /// If it is currently running the scheduler will be stopped.  When the
+    /// [`IoPausedGuard`] is dropped the scheduler is started again.
     ///
     /// 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) -> IoPausedGuard {
-        let mut inner = self.inner.write().await;
-        inner.paused = true;
-        Self::do_stop(inner, &context).await;
-        IoPausedGuard {
-            context,
-            done: false,
+    pub(crate) async fn pause<'a>(&'_ self, context: Context) -> Result<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"))?
+                }
+            }
         }
+
+        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();
+                    }
+                }
+            }
+        });
+        Ok(IoPausedGuard { sender: Some(tx) })
     }
 
     /// Restarts the scheduler, only if it is running.
@@ -117,8 +199,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.scheduler {
-            Some(ref scheduler) => {
+        let (inbox, oboxes) = match *inner {
+            InnerSchedulerState::Started(ref scheduler) => {
                 scheduler.maybe_network();
                 let inbox = scheduler.inbox.conn_state.state.connectivity.clone();
                 let oboxes = scheduler
@@ -128,7 +210,7 @@ impl SchedulerState {
                     .collect::<Vec<_>>();
                 (inbox, oboxes)
             }
-            None => return,
+            _ => return,
         };
         drop(inner);
         connectivity::idle_interrupted(inbox, oboxes).await;
@@ -137,15 +219,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.scheduler {
-            Some(ref scheduler) => {
+        let stores = match *inner {
+            InnerSchedulerState::Started(ref scheduler) => {
                 scheduler.maybe_network_lost();
                 scheduler
                     .boxes()
                     .map(|b| b.conn_state.state.connectivity.clone())
                     .collect()
             }
-            None => return,
+            _ => return,
         };
         drop(inner);
         connectivity::maybe_network_lost(context, stores).await;
@@ -153,72 +235,66 @@ impl SchedulerState {
 
     pub(crate) async fn interrupt_inbox(&self, info: InterruptInfo) {
         let inner = self.inner.read().await;
-        if let Some(ref scheduler) = inner.scheduler {
+        if let InnerSchedulerState::Started(ref scheduler) = *inner {
             scheduler.interrupt_inbox(info);
         }
     }
 
     pub(crate) async fn interrupt_smtp(&self, info: InterruptInfo) {
         let inner = self.inner.read().await;
-        if let Some(ref scheduler) = inner.scheduler {
+        if let InnerSchedulerState::Started(ref scheduler) = *inner {
             scheduler.interrupt_smtp(info);
         }
     }
 
     pub(crate) async fn interrupt_ephemeral_task(&self) {
         let inner = self.inner.read().await;
-        if let Some(ref scheduler) = inner.scheduler {
+        if let InnerSchedulerState::Started(ref scheduler) = *inner {
             scheduler.interrupt_ephemeral_task();
         }
     }
 
     pub(crate) async fn interrupt_location(&self) {
         let inner = self.inner.read().await;
-        if let Some(ref scheduler) = inner.scheduler {
+        if let InnerSchedulerState::Started(ref scheduler) = *inner {
             scheduler.interrupt_location();
         }
     }
 
     pub(crate) async fn interrupt_recently_seen(&self, contact_id: ContactId, timestamp: i64) {
         let inner = self.inner.read().await;
-        if let Some(ref scheduler) = inner.scheduler {
+        if let InnerSchedulerState::Started(ref scheduler) = *inner {
             scheduler.interrupt_recently_seen(contact_id, timestamp);
         }
     }
 }
 
 #[derive(Debug, Default)]
-struct InnerSchedulerState {
-    scheduler: Option<Scheduler>,
-    started: bool,
-    paused: bool,
+enum InnerSchedulerState {
+    Started(Scheduler),
+    #[default]
+    Stopped,
+    Paused {
+        started: bool,
+        pause_guards_count: NonZeroUsize,
+    },
 }
 
+/// Guard to make sure the IO Scheduler is resumed.
+///
+/// Returned by [`SchedulerState::pause`].  To resume the IO scheduler simply drop this
+/// guard.
 #[derive(Debug)]
 pub(crate) struct IoPausedGuard {
-    context: Context,
-    done: bool,
-}
-
-impl IoPausedGuard {
-    pub(crate) async fn resume(&mut self) {
-        self.done = true;
-        let mut inner = self.context.scheduler.inner.write().await;
-        inner.paused = false;
-        if inner.started && inner.scheduler.is_none() {
-            SchedulerState::do_start(inner, self.context.clone()).await;
-        }
-    }
+    sender: Option<oneshot::Sender<()>>,
 }
 
 impl Drop for IoPausedGuard {
     fn drop(&mut self) {
-        if self.done {
-            return;
+        if let Some(sender) = self.sender.take() {
+            // Can only fail if receiver is dropped, but then we're already resumed.
+            sender.send(()).ok();
         }
-
-        // Async .resume() should be called manually due to lack of async drop.
-        error!(self.context, "Pause guard dropped without resuming.");
     }
 }
 
@@ -247,7 +323,11 @@ pub(crate) struct Scheduler {
     recently_seen_loop: RecentlySeenLoop,
 }
 
-async fn inbox_loop(ctx: Context, started: Sender<()>, inbox_handlers: ImapConnectionHandlers) {
+async fn inbox_loop(
+    ctx: Context,
+    started: oneshot::Sender<()>,
+    inbox_handlers: ImapConnectionHandlers,
+) {
     use futures::future::FutureExt;
 
     info!(ctx, "starting inbox loop");
@@ -259,8 +339,8 @@ async fn inbox_loop(ctx: Context, started: Sender<()>, inbox_handlers: ImapConne
     let ctx1 = ctx.clone();
     let fut = async move {
         let ctx = ctx1;
-        if let Err(err) = started.send(()).await {
-            warn!(ctx, "inbox loop, missing started receiver: {}", err);
+        if let Err(()) = started.send(()) {
+            warn!(ctx, "inbox loop, missing started receiver");
             return;
         };
 
@@ -302,7 +382,7 @@ async fn inbox_loop(ctx: Context, started: Sender<()>, inbox_handlers: ImapConne
                             let next_housekeeping_time =
                                 last_housekeeping_time.saturating_add(60 * 60 * 24);
                             if next_housekeeping_time <= time() {
-                                sql::housekeeping(&ctx).await.ok_or_log(&ctx);
+                                sql::housekeeping(&ctx).await.log_err(&ctx).ok();
                             }
                         }
                         Err(err) => {
@@ -411,7 +491,8 @@ async fn fetch_idle(
                 .store_seen_flags_on_imap(ctx)
                 .await
                 .context("store_seen_flags_on_imap")
-                .ok_or_log(ctx);
+                .log_err(ctx)
+                .ok();
         } else {
             warn!(ctx, "No session even though we just prepared it");
         }
@@ -435,7 +516,8 @@ async fn fetch_idle(
     delete_expired_imap_messages(ctx)
         .await
         .context("delete_expired_imap_messages")
-        .ok_or_log(ctx);
+        .log_err(ctx)
+        .ok();
 
     // Scan additional folders only after finishing fetching the watched folder.
     //
@@ -475,10 +557,12 @@ async fn fetch_idle(
         .sync_seen_flags(ctx, &watch_folder)
         .await
         .context("sync_seen_flags")
-        .ok_or_log(ctx);
+        .log_err(ctx)
+        .ok();
 
     connection.connectivity.set_connected(ctx).await;
 
+    ctx.emit_event(EventType::ImapInboxIdle);
     if let Some(session) = connection.session.take() {
         if !session.can_idle() {
             info!(
@@ -520,7 +604,7 @@ async fn fetch_idle(
 
 async fn simple_imap_loop(
     ctx: Context,
-    started: Sender<()>,
+    started: oneshot::Sender<()>,
     inbox_handlers: ImapConnectionHandlers,
     folder_meaning: FolderMeaning,
 ) {
@@ -536,8 +620,8 @@ async fn simple_imap_loop(
 
     let fut = async move {
         let ctx = ctx1;
-        if let Err(err) = started.send(()).await {
-            warn!(&ctx, "simple imap loop, missing started receiver: {}", err);
+        if let Err(()) = started.send(()) {
+            warn!(&ctx, "simple imap loop, missing started receiver");
             return;
         }
 
@@ -555,7 +639,11 @@ async fn simple_imap_loop(
         .await;
 }
 
-async fn smtp_loop(ctx: Context, started: Sender<()>, smtp_handlers: SmtpConnectionHandlers) {
+async fn smtp_loop(
+    ctx: Context,
+    started: oneshot::Sender<()>,
+    smtp_handlers: SmtpConnectionHandlers,
+) {
     use futures::future::FutureExt;
 
     info!(ctx, "starting smtp loop");
@@ -568,8 +656,8 @@ async fn smtp_loop(ctx: Context, started: Sender<()>, smtp_handlers: SmtpConnect
     let ctx1 = ctx.clone();
     let fut = async move {
         let ctx = ctx1;
-        if let Err(err) = started.send(()).await {
-            warn!(&ctx, "smtp loop, missing started receiver: {}", err);
+        if let Err(()) = started.send(()) {
+            warn!(&ctx, "smtp loop, missing started receiver");
             return;
         }
 
@@ -641,7 +729,7 @@ impl Scheduler {
     pub async fn start(ctx: Context) -> Result<Self> {
         let (smtp, smtp_handlers) = SmtpConnectionState::new();
 
-        let (smtp_start_send, smtp_start_recv) = channel::bounded(1);
+        let (smtp_start_send, smtp_start_recv) = oneshot::channel();
         let (ephemeral_interrupt_send, ephemeral_interrupt_recv) = channel::bounded(1);
         let (location_interrupt_send, location_interrupt_recv) = channel::bounded(1);
 
@@ -649,7 +737,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) = channel::bounded(1);
+        let (inbox_start_send, inbox_start_recv) = oneshot::channel();
         let handle = {
             let ctx = ctx.clone();
             task::spawn(inbox_loop(ctx, inbox_start_send, inbox_handlers))
@@ -670,7 +758,7 @@ impl Scheduler {
         ] {
             if should_watch? {
                 let (conn_state, handlers) = ImapConnectionState::new(&ctx).await?;
-                let (start_send, start_recv) = channel::bounded(1);
+                let (start_send, start_recv) = oneshot::channel();
                 let ctx = ctx.clone();
                 let handle = task::spawn(simple_imap_loop(ctx, start_send, handlers, meaning));
                 oboxes.push(SchedBox {
@@ -717,7 +805,7 @@ impl Scheduler {
         };
 
         // wait for all loops to be started
-        if let Err(err) = try_join_all(start_recvs.iter().map(|r| r.recv())).await {
+        if let Err(err) = try_join_all(start_recvs).await {
             bail!("failed to start scheduler: {}", err);
         }
 
@@ -770,20 +858,22 @@ 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.ok_or_log(context);
+            b.conn_state.stop().await.log_err(context).ok();
         }
-        self.smtp.stop().await.ok_or_log(context);
+        self.smtp.stop().await.log_err(context).ok();
 
         // 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
-                .ok_or_log(context);
+                .log_err(context)
+                .ok();
         }
         tokio::time::timeout(timeout_duration, self.smtp_handle)
             .await
-            .ok_or_log(context);
+            .log_err(context)
+            .ok();
         self.ephemeral_handle.abort();
         self.location_handle.abort();
         self.recently_seen_loop.abort();

src/scheduler/connectivity.rs

@@ -14,6 +14,8 @@ 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,
@@ -226,12 +228,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.scheduler {
-            Some(ref sched) => sched
+        let stores: Vec<_> = match *lock {
+            InnerSchedulerState::Started(ref sched) => sched
                 .boxes()
                 .map(|b| b.conn_state.state.connectivity.clone())
                 .collect(),
-            None => return Connectivity::NotConnected,
+            _ => return Connectivity::NotConnected,
         };
         drop(lock);
 
@@ -309,15 +311,15 @@ impl Context {
         // =============================================================================================
 
         let lock = self.scheduler.inner.read().await;
-        let (folders_states, smtp) = match lock.scheduler {
-            Some(ref sched) => (
+        let (folders_states, smtp) = match *lock {
+            InnerSchedulerState::Started(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"));
             }
         };
@@ -337,7 +339,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.ok_or_log(self).flatten();
+                let f = self.get_config(config).await.log_err(self).ok().flatten();
 
                 if let Some(foldername) = f {
                     let detailed = &state.get_detailed().await;
@@ -396,64 +398,72 @@ impl Context {
         if let Some(quota) = &*quota {
             match &quota.recent {
                 Ok(quota) => {
-                    let roots_cnt = quota.len();
-                    for (root_name, resources) in quota {
-                        use async_imap::types::QuotaResourceName::*;
-                        for resource in resources {
-                            ret += "<li>";
+                    if !quota.is_empty() {
+                        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 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);
+                                // 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>";
                             }
-
-                            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) => {
@@ -480,14 +490,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.scheduler {
-            Some(ref sched) => sched
+        let stores: Vec<_> = match *lock {
+            InnerSchedulerState::Started(ref sched) => sched
                 .boxes()
                 .map(|b| &b.conn_state.state)
                 .chain(once(&sched.smtp.state))
                 .map(|state| state.connectivity.clone())
                 .collect(),
-            None => return false,
+            _ => return false,
         };
         drop(lock);
 

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=?;"#,
-                    params![SecureJoinStep::Terminated],
+                    (SecureJoinStep::Terminated,),
                 )?;
                 let mut stmt = transaction.prepare("SELECT id FROM bobstate;")?;
                 let mut aborted = Vec::new();
-                for id in stmt.query_map(params![], |row| row.get::<_, i64>(0))? {
+                for id in stmt.query_map((), |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;", params![])?;
+                transaction.execute("DELETE FROM bobstate;", ())?;
                 transaction.execute(
                     "INSERT INTO bobstate (invite, next_step, chat_id) VALUES (?, ?, ?);",
-                    params![invite, next, chat_id],
+                    (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=?;",
-            params![id],
+            (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=?;",
-                    paramsv![next, self.id],
+                    (next, self.id),
                 )
                 .await?;
             }
             SecureJoinStep::Terminated | SecureJoinStep::Completed => {
-                sql.execute("DELETE FROM bobstate WHERE id=?;", paramsv!(self.id))
+                sql.execute("DELETE FROM bobstate WHERE id=?;", (self.id,))
                     .await?;
             }
         }

src/smtp.rs

@@ -520,10 +520,7 @@ pub(crate) async fn send_msg_to_smtp(
     // database.
     context
         .sql
-        .execute(
-            "UPDATE smtp SET retries=retries+1 WHERE id=?",
-            paramsv![rowid],
-        )
+        .execute("UPDATE smtp SET retries=retries+1 WHERE id=?", (rowid,))
         .await
         .context("failed to update retries count")?;
 
@@ -531,7 +528,7 @@ pub(crate) async fn send_msg_to_smtp(
         .sql
         .query_row(
             "SELECT mime, recipients, msg_id, retries FROM smtp WHERE id=?",
-            paramsv![rowid],
+            (rowid,),
             |row| {
                 let mime: String = row.get(0)?;
                 let recipients: String = row.get(1)?;
@@ -545,7 +542,7 @@ 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=?", paramsv![rowid])
+            .execute("DELETE FROM smtp WHERE id=?", (rowid,))
             .await
             .context("failed to remove message with exceeded retry limit from smtp table")?;
         bail!("Number of retries exceeded the limit");
@@ -588,7 +585,7 @@ pub(crate) async fn send_msg_to_smtp(
         SendResult::Success | SendResult::Failure(_) => {
             context
                 .sql
-                .execute("DELETE FROM smtp WHERE id=?", paramsv![rowid])
+                .execute("DELETE FROM smtp WHERE id=?", (rowid,))
                 .await?;
         }
     };
@@ -637,7 +634,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)
@@ -691,7 +688,7 @@ async fn send_mdn_msg_id(
             "SELECT msg_id, rfc724_mid
              FROM smtp_mdns
              WHERE from_id=? AND msg_id!=?",
-            paramsv![contact_id, msg_id],
+            (contact_id, msg_id),
             |row| {
                 let msg_id: MsgId = row.get(0)?;
                 let rfc724_mid: String = row.get(1)?;
@@ -718,7 +715,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 = ?", paramsv![msg_id])
+                .execute("DELETE FROM smtp_mdns WHERE msg_id = ?", (msg_id,))
                 .await?;
             if !additional_msg_ids.is_empty() {
                 let q = format!(
@@ -779,7 +776,7 @@ async fn send_mdn(context: &Context, smtp: &mut Smtp) -> Result<bool> {
         .sql
         .execute(
             "UPDATE smtp_mdns SET retries=retries+1 WHERE msg_id=?",
-            paramsv![msg_id],
+            (msg_id,),
         )
         .await
         .context("failed to update MDN retries count")?;
@@ -789,7 +786,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 = ?", paramsv![msg_id])
+            .execute("DELETE FROM smtp_mdns WHERE msg_id = ?", (msg_id,))
             .await?;
         Err(err)
     } else {

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, Connection, OpenFlags};
+use rusqlite::{self, config::DbConfig, types::ValueRef, Connection, OpenFlags, Row};
 use tokio::sync::{Mutex, MutexGuard, RwLock};
 
 use crate::blob::BlobObject;
@@ -23,27 +23,28 @@ use crate::peerstate::{deduplicate_peerstates, Peerstate};
 use crate::stock_str;
 use crate::tools::{delete_file, time};
 
-#[allow(missing_docs)]
+/// 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.
 #[macro_export]
-macro_rules! paramsv {
-    () => {
-        rusqlite::params_from_iter(Vec::<&dyn $crate::ToSql>::new())
-    };
-    ($($param:expr),+ $(,)?) => {
-        rusqlite::params_from_iter(vec![$(&$param as &dyn $crate::ToSql),+])
+macro_rules! params_slice {
+    ($($param:expr),+) => {
+        [$(&$param 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)
+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)
 }
 
 mod migrations;
@@ -57,7 +58,7 @@ pub struct Sql {
     /// Database file path
     pub(crate) dbfile: PathBuf,
 
-    /// Write transaction mutex.
+    /// Write transactions mutex.
     ///
     /// See [`Self::write_lock`].
     write_mtx: Mutex<()>,
@@ -139,11 +140,8 @@ 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 ?",
-                    paramsv![path_str, passphrase],
-                )
-                .context("failed to attach backup database")?;
+                conn.execute("ATTACH DATABASE ? AS backup KEY ?", (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")
@@ -556,27 +554,21 @@ 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=?;",
-                    paramsv![key],
-                )
+                .exists("SELECT COUNT(*) FROM config WHERE keyname=?;", (key,))
                 .await?;
 
             if exists {
-                self.execute(
-                    "UPDATE config SET value=? WHERE keyname=?;",
-                    paramsv![value, key],
-                )
-                .await?;
+                self.execute("UPDATE config SET value=? WHERE keyname=?;", (value, key))
+                    .await?;
             } else {
                 self.execute(
                     "INSERT INTO config (keyname, value) VALUES (?, ?);",
-                    paramsv![key, value],
+                    (key, value),
                 )
                 .await?;
             }
         } else {
-            self.execute("DELETE FROM config WHERE keyname=?;", paramsv![key])
+            self.execute("DELETE FROM config WHERE keyname=?;", (key,))
                 .await?;
         }
         lock.insert(key.to_string(), value.map(|s| s.to_string()));
@@ -597,7 +589,7 @@ impl Sql {
 
         let mut lock = self.config_cache.write().await;
         let value = self
-            .query_get_value("SELECT value FROM config WHERE keyname=?;", paramsv![key])
+            .query_get_value("SELECT value FROM config WHERE keyname=?;", (key,))
             .await
             .context(format!("failed to fetch raw config: {key}"))?;
         lock.insert(key.to_string(), value.clone());
@@ -696,29 +688,38 @@ 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,
-            "Housekeeping: cannot remove unused files: {:#}", err
+            "Housekeeping: cannot remove unused files: {:#}.", err
         );
     }
 
     if let Err(err) = start_ephemeral_timers(context).await {
         warn!(
             context,
-            "Housekeeping: cannot start ephemeral timers: {:#}", err
+            "Housekeeping: cannot start ephemeral timers: {:#}.", err
         );
     }
 
     if let Err(err) = prune_tombstones(&context.sql).await {
         warn!(
             context,
-            "Housekeeping: Cannot prune message tombstones: {:#}", err
+            "Housekeeping: Cannot prune message tombstones: {:#}.", err
         );
     }
 
     if let Err(err) = deduplicate_peerstates(&context.sql).await {
-        warn!(context, "Failed to deduplicate peerstates: {:#}", err)
+        warn!(context, "Failed to deduplicate peerstates: {:#}.", err)
     }
 
     context.schedule_quota_update().await?;
@@ -731,7 +732,7 @@ pub async fn housekeeping(context: &Context) -> Result<()> {
         .await
     {
         Err(err) => {
-            warn!(context, "Failed to run incremental vacuum: {err:#}");
+            warn!(context, "Failed to run incremental vacuum: {err:#}.");
         }
         Ok(Some(())) => {
             // Incremental vacuum returns a zero-column result if it did anything.
@@ -743,13 +744,6 @@ 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(
@@ -757,12 +751,24 @@ pub async fn housekeeping(context: &Context) -> Result<()> {
             (),
         )
         .await
-        .ok_or_log_msg(context, "failed to remove old MDNs");
+        .context("failed to remove old MDNs")
+        .log_err(context)
+        .ok();
 
     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();
@@ -814,7 +820,7 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
         .await
         .context("housekeeping: failed to SELECT value FROM config")?;
 
-    info!(context, "{} files in use.", files_in_use.len(),);
+    info!(context, "{} files in use.", files_in_use.len());
     /* go through directories and delete unused files */
     let blobdir = context.get_blobdir();
     for p in [&blobdir.join(BLOBS_BACKUP_NAME), blobdir] {
@@ -846,7 +852,7 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
                                 // environment f.e. So, no warning.
                                 info!(
                                     context,
-                                    "Housekeeping: Cannot rmdir {}: {:#}",
+                                    "Housekeeping: Cannot rmdir {}: {:#}.",
                                     entry.path().display(),
                                     e
                                 );
@@ -868,7 +874,7 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
                         {
                             info!(
                                 context,
-                                "Housekeeping: Keeping new unreferenced file #{}: {:?}",
+                                "Housekeeping: Keeping new unreferenced file #{}: {:?}.",
                                 unreferenced_count,
                                 entry.file_name(),
                             );
@@ -879,7 +885,7 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
                     }
                     info!(
                         context,
-                        "Housekeeping: Deleting unreferenced file #{}: {:?}",
+                        "Housekeeping: Deleting unreferenced file #{}: {:?}.",
                         unreferenced_count,
                         entry.file_name()
                     );
@@ -895,12 +901,14 @@ pub async fn remove_unused_files(context: &Context) -> Result<()> {
                 }
             }
             Err(err) => {
-                warn!(
-                    context,
-                    "Housekeeping: Cannot read dir {}: {:#}",
-                    p.display(),
-                    err
-                );
+                if !p.ends_with(BLOBS_BACKUP_NAME) {
+                    warn!(
+                        context,
+                        "Housekeeping: Cannot read dir {}: {:#}.",
+                        p.display(),
+                        err
+                    );
+                }
             }
         }
     }
@@ -964,7 +972,7 @@ async fn prune_tombstones(sql: &Sql) -> Result<()> {
          AND NOT EXISTS (
          SELECT * FROM imap WHERE msgs.rfc724_mid=rfc724_mid AND target!=''
          )",
-        paramsv![DC_CHAT_ID_TRASH],
+        (DC_CHAT_ID_TRASH,),
     )
     .await?;
     Ok(())
@@ -1147,12 +1155,12 @@ mod tests {
         sql.open(&t, "".to_string()).await?;
         sql.execute(
             "INSERT INTO config (keyname, value) VALUES (?, ?);",
-            paramsv!("foo", "bar"),
+            ("foo", "bar"),
         )
         .await?;
 
         let value: Option<String> = sql
-            .query_get_value("SELECT value FROM config WHERE keyname=?;", paramsv!("foo"))
+            .query_get_value("SELECT value FROM config WHERE keyname=?;", ("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 (?, ?);",
-                paramsv![VERSION_CFG, format!("{dbversion_before_update}")],
+                (VERSION_CFG, format!("{dbversion_before_update}")),
             )?;
             Ok(())
         })
@@ -704,6 +704,13 @@ 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)
@@ -735,14 +742,18 @@ impl Sql {
         Ok(())
     }
 
-    async fn execute_migration(&self, query: &'static str, version: i32) -> Result<()> {
-        self.transaction(move |transaction| {
-            // set raw config inside the transaction
-            transaction.execute(
-                "UPDATE config SET value=? WHERE keyname=?;",
-                paramsv![format!("{version}"), VERSION_CFG],
-            )?;
+    // 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<()> {
+        self.transaction(move |transaction| {
+            Self::set_db_version_trans(transaction, version)?;
             transaction.execute_batch(query)?;
 
             Ok(())

src/stock_str.rs

@@ -407,6 +407,9 @@ pub enum StockMessage {
 
     #[strum(props(fallback = "Scan to set up second device for %1$s"))]
     BackupTransferQr = 162,
+
+    #[strum(props(fallback = "ℹ️ Account transferred to your second device."))]
+    BackupTransferMsgBody = 163,
 }
 
 impl StockMessage {
@@ -1261,6 +1264,10 @@ pub(crate) async fn backup_transfer_qr(context: &Context) -> Result<String> {
         .replace1(&full_name))
 }
 
+pub(crate) async fn backup_transfer_msg_body(context: &Context) -> String {
+    translated(context, StockMessage::BackupTransferMsgBody).await
+}
+
 impl Context {
     /// Set the stock string for the [StockMessage].
     ///

src/sync.rs

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