api: add dc_replace_webxdc()

.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
     name: Lint Rust
     runs-on: ubuntu-latest
     env:
-      RUSTUP_TOOLCHAIN: 1.73.0
+      RUSTUP_TOOLCHAIN: 1.72.0
     steps:
       - uses: actions/checkout@v3
       - name: Install rustfmt and clippy
@@ -39,6 +39,10 @@ jobs:
       - name: Check
         run: cargo check --workspace --all-targets --all-features
 
+      # Check with musl libc target which is used for `deltachat-rpc-server` releases.
+      - name: Check musl
+        run: scripts/zig-musl-check.sh
+
   cargo_deny:
     name: cargo deny
     runs-on: ubuntu-latest
@@ -77,11 +81,11 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            rust: 1.73.0
+            rust: 1.68.2
           - os: windows-latest
-            rust: 1.73.0
+            rust: 1.68.2
           - os: macos-latest
-            rust: 1.73.0
+            rust: 1.68.2
 
           # Minimum Supported Rust Version = 1.65.0
           #
@@ -178,15 +182,15 @@ jobs:
         include:
           # Currently used Rust version.
           - os: ubuntu-latest
-            python: 3.12
+            python: 3.11
           - os: macos-latest
-            python: 3.12
+            python: 3.11
 
           # PyPy tests
           - os: ubuntu-latest
-            python: pypy3.10
+            python: pypy3.9
           - os: macos-latest
-            python: pypy3.10
+            python: pypy3.9
 
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
@@ -228,19 +232,22 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            python: 3.12
+            python: 3.11
           - os: macos-latest
-            python: 3.12
+            python: 3.11
 
           # PyPy tests
           - os: ubuntu-latest
-            python: pypy3.10
+            python: pypy3.9
           - os: macos-latest
-            python: pypy3.10
+            python: pypy3.9
 
-          # Minimum Supported Python Version = 3.7
+          # Minimum Supported Python Version = 3.8
+          #
+          # Python 3.7 has at least one known bug related to starting subprocesses
+          # in asyncio programs: <https://bugs.python.org/issue35621>
           - os: ubuntu-latest
-            python: 3.7
+            python: 3.8
 
     runs-on: ${{ matrix.os }}
     steps:

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

@@ -26,17 +26,35 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Install ziglang
-        run: pip install wheel ziglang==0.11.0
-
-      - name: Build deltachat-rpc-server binaries
+      - name: Build
         run: sh scripts/zig-rpc-server.sh
 
-      - name: Upload dist directory with Linux binaries
+      - name: Upload x86_64 binary
         uses: actions/upload-artifact@v3
         with:
-          name: linux
-          path: dist/
+          name: deltachat-rpc-server-x86_64
+          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:
+          name: deltachat-rpc-server-aarch64
+          path: target/aarch64-unknown-linux-musl/release/deltachat-rpc-server
+          if-no-files-found: error
+
+      - name: Upload armv7 binary
+        uses: actions/upload-artifact@v3
+        with:
+          name: deltachat-rpc-server-armv7
+          path: target/armv7-unknown-linux-musleabihf/release/deltachat-rpc-server
           if-no-files-found: error
 
   build_windows:
@@ -74,87 +92,39 @@ jobs:
 
   build_macos:
     name: Build deltachat-rpc-server for macOS
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - arch: x86_64
-          - arch: aarch64
-
     runs-on: macos-latest
     steps:
       - uses: actions/checkout@v3
 
       - name: Setup rust target
-        run: rustup target add ${{ matrix.arch }}-apple-darwin
+        run: rustup target add x86_64-apple-darwin
 
       - name: Build
-        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.arch }}-apple-darwin --features vendored
+        run: cargo build --release --package deltachat-rpc-server --target x86_64-apple-darwin --features vendored
 
       - name: Upload binary
         uses: actions/upload-artifact@v3
         with:
-          name: deltachat-rpc-server-${{ matrix.arch }}-macos
-          path: target/${{ matrix.arch }}-apple-darwin/release/deltachat-rpc-server
+          name: deltachat-rpc-server-x86_64-macos
+          path: target/x86_64-apple-darwin/release/deltachat-rpc-server
           if-no-files-found: error
 
   publish:
-    name: Build wheels and upload binaries to the release
+    name: Upload binaries to the release
     needs: ["build_linux", "build_windows", "build_macos"]
     permissions:
       contents: write
     runs-on: "ubuntu-latest"
     steps:
-      - uses: actions/checkout@v3
+      - name: Download built binaries
+        uses: "actions/download-artifact@v3"
 
-      - name: Download Linux binaries
-        uses: actions/download-artifact@v3
-        with:
-          name: linux
-          path: dist/
-
-      - name: Download win32 binary
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-win32.exe
-          path: deltachat-rpc-server-win32.exe.d
-
-      - name: Download win64 binary
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-win64.exe
-          path: deltachat-rpc-server-win64.exe.d
-
-      - name: Download macOS binary for x86_64
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-x86_64-macos
-          path: deltachat-rpc-server-x86_64-macos.d
-
-      - name: Download macOS binary for aarch64
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-aarch64-macos
-          path: deltachat-rpc-server-aarch64-macos.d
-
-      - name: Flatten dist/ directory
+      - name: Compose dist/ directory
         run: |
-          mv deltachat-rpc-server-win32.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win32.exe
-          mv deltachat-rpc-server-win64.exe.d/deltachat-rpc-server.exe dist/deltachat-rpc-server-win64.exe
-          mv deltachat-rpc-server-x86_64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-macos
-          mv deltachat-rpc-server-aarch64-macos.d/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-macos
-
-      # Python 3.11 is needed for tomllib used in scripts/wheel-rpc-server.py
-      - name: Install python 3.12
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.12
-
-      - name: Install wheel
-        run: pip install wheel
-
-      - name: Build deltachat-rpc-server Python wheels and source package
-        run: scripts/wheel-rpc-server.py
+          mkdir dist
+          for x in x86_64 i686 aarch64 armv7 win32.exe win64.exe x86_64-macos; do
+            mv "deltachat-rpc-server-$x"/* "dist/deltachat-rpc-server-$x"
+          done
 
       - name: List downloaded artifacts
         run: ls -l dist/

.gitignore

@@ -1,7 +1,6 @@
 /target
 **/*.rs.bk
 /build
-/dist
 
 # ignore vi temporaries
 *~
@@ -19,9 +18,6 @@ python/.eggs
 __pycache__
 python/src/deltachat/capi*.so
 python/.venv/
-python/venv/
-venv/
-env/
 
 python/liveconfig*
 

CHANGELOG.md

@@ -1,151 +1,5 @@
 # Changelog
 
-## [1.126.1] - 2023-10-24
-
-### Fixes
-
-- Do not hardcode version in deltachat-rpc-server source package.
-- Do not interrupt IMAP loop from `get_connectivity_html()`.
-
-### Features / Changes
-
-- imap: Buffer `STARTTLS` command.
-
-### Build system
-
-- Build `deltachat-rpc-server` binary for aarch64 macOS.
-- Build `deltachat-rpc-server` wheels for macOS and Windows.
-
-### Refactor
-
-- Remove job queue.
-
-### Miscellaneous Tasks
-
-- cargo: Update `ahash` to make `cargo-deny` happy.
-
-## [1.126.0] - 2023-10-22
-
-### API-Changes
-
-- Allow to filter by unread in `chatlist:try_load` ([#4824](https://github.com/deltachat/deltachat-core-rust/pull/4824)).
-- Add `misc_send_draft()` to JSON-RPC API ([#4839](https://github.com/deltachat/deltachat-core-rust/pull/4839)).
-
-### Features / Changes
-
-- [**breaking**] Make broadcast lists create their own chat ([#4644](https://github.com/deltachat/deltachat-core-rust/pull/4644)).
-  - This means that UIs need to ask for the name when creating a broadcast list, similar to <https://github.com/deltachat/deltachat-android/pull/2653>.
-- Add self-address to backup filename ([#4820](https://github.com/deltachat/deltachat-core-rust/pull/4820))
-
-### CI
-
-- Build Python wheels for deltachat-rpc-server.
-
-### Build system
-
-- Strip release binaries.
-- Workaround OpenSSL crate expecting libatomic to be available.
-
-### Fixes
-
-- Set `soft_heap_limit` on SQLite database.
-- imap: Fallback to `STATUS` if `SELECT` did not return UIDNEXT.
-
-## [1.125.0] - 2023-10-14
-
-### API-Changes
-
-- [**breaking**] deltachat-rpc-client: Replace `asyncio` with threads.
-- Validate boolean values passed to `set_config`. Attempts to set values other than `0` and `1` will result in an error.
-
-### CI
-
-- Reduce required Python version for deltachat-rpc-client from 3.8 to 3.7.
-
-### Features / Changes
-
-- Add developer option to disable IDLE.
-
-### Fixes
-
-- `deltachat-rpc-client`: Run `deltachat-rpc-server` in its own process group. This prevents reception of `SIGINT` by the server when the bot is terminated with `^C`.
-- python: Don't automatically set the displayname to "bot" when setting log level.
-- Don't update `timestamp`, `timestamp_rcvd`, `state` when replacing partially downloaded message ([#4700](https://github.com/deltachat/deltachat-core-rust/pull/4700)).
-- Assign encrypted partially downloaded group messages to 1:1 chat ([#4757](https://github.com/deltachat/deltachat-core-rust/pull/4757)).
-- Return all contacts from `Contact::get_all` for bots ([#4811](https://github.com/deltachat/deltachat-core-rust/pull/4811)).
-- Set connectivity status to "connected" during fake idle.
-- Return verifier contacts regardless of their origin.
-- Don't try to send more MDNs if there's a temporary SMTP error ([#4534](https://github.com/deltachat/deltachat-core-rust/pull/4534)).
-
-### Refactor
-
-- deltachat-rpc-client: Close stdin instead of sending `SIGTERM`.
-- deltachat-rpc-client: Remove print() calls. Standard `logging` package is for logging instead.
-
-### Tests
-
-- deltachat-rpc-client: Enable logs in pytest.
-
-## [1.124.1] - 2023-10-05
-
-### Fixes
-
-- Remove footer from reactions on the receiver side ([#4780](https://github.com/deltachat/deltachat-core-rust/pull/4780)).
-
-### CI
-
-- Pin `urllib3` version to `<2`. ([#4788](https://github.com/deltachat/deltachat-core-rust/issues/4788))
-
-## [1.124.0] - 2023-10-04
-
-### API-Changes
-
-- [**breaking**] Return `DC_CONTACT_ID_SELF` from `dc_contact_get_verifier_id()` for directly verified contacts.
-- Deprecate `dc_contact_get_verifier_addr`.
-- python: use `dc_contact_get_verifier_id()`. `get_verifier()` returns a Contact rather than an address now.
-- Deprecate `get_next_media()`.
-- Ignore public key argument in `dc_preconfigure_keypair()`. Public key is extracted from the private key.
-
-### Fixes
-
-- Wrap base64-encoded parts to 76 characters.
-- Require valid email addresses in `dc_provider_new_from_email[_with_dns]`.
-- Do not trash messages with attachments and no text when `location.kml` is attached ([#4749](https://github.com/deltachat/deltachat-core-rust/issues/4749)).
-- Initialise `last_msg_id` to the highest known row id. This ensures bots migrated from older version to `dc_get_next_msgs()` API do not process all previous messages from scratch.
-- Do not put the status footer into reaction MIME parts.
-- Ignore special chats in `get_similar_chat_ids()`. This prevents trash chat from showing up in similar chat list ([#4756](https://github.com/deltachat/deltachat-core-rust/issues/4756)).
-- Cap percentage in connectivity layout to 100% ([#4765](https://github.com/deltachat/deltachat-core-rust/pull/4765)).
-- Add Let's Encrypt root certificate to `reqwest`. This should allow scanning `DCACCOUNT` QR-codes on older Android phones when the server has a Let's Encrypt certificate.
-- deltachat-rpc-client: Increase stdio buffer to 64 MiB to avoid Python bots crashing when trying to load large messages via a JSON-RPC call.
-- Add `protected-headers` directive to Content-Type of encrypted messages with attachments ([#2302](https://github.com/deltachat/deltachat-core-rust/issues/2302)). This makes Thunderbird show encrypted Subject for Delta Chat messages.
-- webxdc: Reset `document.update` on forwarding. This fixes the test `test_forward_webxdc_instance()`.
-
-### Features / Changes
-
-- Remove extra members from the local list in sake of group membership consistency ([#3782](https://github.com/deltachat/deltachat-core-rust/issues/3782)).
-- deltachat-rpc-client: Log exceptions when long-running tasks die.
-
-### Build
-
-- Build wheels for Python 3.12 and PyPy 3.10.
-
-## [1.123.0] - 2023-09-22
-
-### API-Changes
-
-- Make it possible to import secret key from a file with `DC_IMEX_IMPORT_SELF_KEYS`.
-- [**breaking**] Make `dc_jsonrpc_blocking_call` accept JSON-RPC request.
-
-### Fixes
-
-- `lookup_chat_by_reply()`: Skip not fully downloaded and undecipherable messages ([#4676](https://github.com/deltachat/deltachat-core-rust/pull/4676)).
-- `lookup_chat_by_reply()`: Skip undecipherable parent messages created by older versions ([#4676](https://github.com/deltachat/deltachat-core-rust/pull/4676)).
-- imex: Use "default" in the filename of the default key.
-
-### Miscellaneous Tasks
-
-- Update OpenSSL from 3.1.2 to 3.1.3.
-
 ## [1.122.0] - 2023-09-12
 
 ### API-Changes
@@ -2962,8 +2816,3 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.120.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.119.1...v1.120.0
 [1.121.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.120.0...v1.121.0
 [1.122.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.121.0...v1.122.0
-[1.123.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.122.0...v1.123.0
-[1.124.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.123.0...v1.124.0
-[1.124.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.124.0...v1.124.1
-[1.125.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.124.1...v1.125.0
-[1.126.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.125.0...v1.126.0

Cargo.lock

@@ -43,14 +43,24 @@ dependencies = [
 
 [[package]]
 name = "ahash"
-version = "0.8.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7d5a2cecb58716e47d67d5703a249964b14c7be1ec3cad3affc295b2d1c35d"
+checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+dependencies = [
+ "getrandom 0.2.10",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
 dependencies = [
  "cfg-if",
  "once_cell",
  "version_check",
- "zerocopy",
 ]
 
 [[package]]
@@ -211,9 +221,9 @@ dependencies = [
 
 [[package]]
 name = "async-imap"
-version = "0.9.2"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "936c1b580be4373b48c9c687e0c79285441664398354df28d0860087cac0c069"
+checksum = "b538b767cbf9c162a6c5795d4b932bd2c20ba10b5a91a94d2b2b6886c1dce6a8"
 dependencies = [
  "async-channel",
  "base64 0.21.2",
@@ -302,9 +312,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "axum"
-version = "0.6.20"
+version = "0.6.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b829e4e32b91e643de6eafe82b1d90675f5874230191a4ffbc1b336dec4d6bf"
+checksum = "f8175979259124331c1d7bf6586ee7e0da434155e4b2d48ec2c8386281d8df39"
 dependencies = [
  "async-trait",
  "axum-core",
@@ -1093,7 +1103,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat"
-version = "1.126.1"
+version = "1.122.0"
 dependencies = [
  "ansi_term",
  "anyhow",
@@ -1169,7 +1179,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-jsonrpc"
-version = "1.126.1"
+version = "1.122.0"
 dependencies = [
  "anyhow",
  "async-channel",
@@ -1193,7 +1203,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-repl"
-version = "1.126.1"
+version = "1.122.0"
 dependencies = [
  "ansi_term",
  "anyhow",
@@ -1208,7 +1218,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-rpc-server"
-version = "1.126.1"
+version = "1.122.0"
 dependencies = [
  "anyhow",
  "deltachat",
@@ -1233,7 +1243,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat_ffi"
-version = "1.126.1"
+version = "1.122.0"
 dependencies = [
  "anyhow",
  "deltachat",
@@ -1595,7 +1605,7 @@ dependencies = [
 [[package]]
 name = "email"
 version = "0.0.21"
-source = "git+https://github.com/deltachat/rust-email?branch=master#37778c89d5eb5a94b7983f3f37ff67769bde3cf9"
+source = "git+https://github.com/deltachat/rust-email?branch=master#25702df99254d059483b41417cd80696a258df8e"
 dependencies = [
  "base64 0.11.0",
  "chrono",
@@ -2161,14 +2171,17 @@ name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.6",
+]
 
 [[package]]
 name = "hashbrown"
-version = "0.14.2"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156"
+checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
 dependencies = [
- "ahash",
+ "ahash 0.8.3",
  "allocator-api2",
 ]
 
@@ -2178,7 +2191,7 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "312f66718a2d7789ffef4f4b7b213138ed9f1eb3aa1d0d82fc99f88fb3ffd26f"
 dependencies = [
- "hashbrown 0.14.2",
+ "hashbrown 0.14.0",
 ]
 
 [[package]]
@@ -2438,7 +2451,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.2",
+ "hashbrown 0.14.0",
 ]
 
 [[package]]
@@ -3097,9 +3110,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-src"
-version = "300.1.5+3.1.3"
+version = "300.1.3+3.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "559068e4c12950d7dcaa1857a61725c0d38d4fc03ff8e070ab31a75d6e316491"
+checksum = "cd2c101a165fff9935e34def4669595ab1c7847943c42be86e21503e482be107"
 dependencies = [
  "cc",
 ]
@@ -4934,9 +4947,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.20.1"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
+checksum = "54319c93411147bced34cb5609a80e0a8e44c5999c93903a81cd866630ec0bfd"
 dependencies = [
  "futures-util",
  "log",
@@ -5146,13 +5159,13 @@ checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
 
 [[package]]
 name = "tungstenite"
-version = "0.20.1"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
+checksum = "30ee6ab729cd4cf0fd55218530c4522ed30b7b6081752839b68fcec8d0960788"
 dependencies = [
+ "base64 0.13.1",
  "byteorder",
  "bytes",
- "data-encoding",
  "http",
  "httparse",
  "log",
@@ -5222,9 +5235,13 @@ checksum = "22049a19f4a68748a168c0fc439f9516686aa045927ff767eca0a85101fb6e73"
 
 [[package]]
 name = "unicode-linebreak"
-version = "0.1.5"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
+checksum = "c5faade31a542b8b35855fff6e8def199853b2da8da256da52f52f1316ee3137"
+dependencies = [
+ "hashbrown 0.12.3",
+ "regex",
+]
 
 [[package]]
 name = "unicode-normalization"
@@ -5431,9 +5448,9 @@ dependencies = [
 
 [[package]]
 name = "webpki"
-version = "0.22.2"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07ecc0cd7cac091bf682ec5efa18b1cff79d617b84181f38b3951dbe135f607f"
+checksum = "f0e74f82d49d545ad128049b7e88f6576df2da6b02e9ce565c6f533be576957e"
 dependencies = [
  "ring",
  "untrusted",
@@ -5793,26 +5810,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "zerocopy"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a7af71d8643341260a65f89fa60c0eeaa907f34544d8f6d9b0df72f069b5e74"
-dependencies = [
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9731702e2f0617ad526794ae28fbc6f6ca8849b5ba729666c2a5bc4b6ddee2cd"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.23",
-]
-
 [[package]]
 name = "zeroize"
 version = "1.6.0"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.126.1"
+version = "1.122.0"
 edition = "2021"
 license = "MPL-2.0"
 rust-version = "1.65"
@@ -24,7 +24,6 @@ lto = true
 panic = 'abort'
 opt-level = "z"
 codegen-units = 1
-strip = true
 
 [patch.crates-io]
 quinn-udp = { git = "https://github.com/quinn-rs/quinn", branch="main" }

deltachat-ffi/Cargo.toml

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

deltachat-ffi/deltachat.h

@@ -492,9 +492,6 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  * - `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.
- * - `disable_idle` = 1=disable IMAP IDLE even if the server supports it,
- *                    0=use IMAP IDLE if the server supports it.
- *                    This is a developer option used for testing polling used as an IDLE fallback.
  * - `download_limit` = Messages up to this number of bytes are downloaded automatically.
  *                    For larger messages, only the header is downloaded and a placeholder is shown.
  *                    These messages can be downloaded fully using dc_download_full_msg() later.
@@ -503,9 +500,6 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    to not mess up with non-delivery-reports or read-receipts.
  *                    0=no limit (default).
  *                    Changes affect future messages only.
- * - `gossip_period` = How often to gossip Autocrypt keys in chats with multiple recipients, in
- *                    seconds. 2 days by default.
- *                    This is not supposed to be changed by UIs and only used for testing.
  * - `ui.*`         = All keys prefixed by `ui.` can be used by the user-interfaces for system-specific purposes.
  *                    The prefix should be followed by the system and maybe subsystem,
  *                    e.g. `ui.desktop.foo`, `ui.desktop.linux.bar`, `ui.android.foo`, `ui.dc40.bar`, `ui.bot.simplebot.baz`.
@@ -830,7 +824,7 @@ void            dc_maybe_network             (dc_context_t* context);
  * @param context The context as created by dc_context_new().
  * @param addr The e-mail address of the user. This must match the
  *    configured_addr setting of the context as well as the UID of the key.
- * @param public_data Ignored, actual public key is extracted from secret_data.
+ * @param public_data ASCII armored public key.
  * @param secret_data ASCII armored secret key.
  * @return 1 on success, 0 on failure.
  */
@@ -884,8 +878,7 @@ int             dc_preconfigure_keypair        (dc_context_t* context, const cha
  *     - if the flag DC_GCL_ADD_ALLDONE_HINT is set, DC_CHAT_ID_ALLDONE_HINT
  *       is added as needed.
  * @param query_str An optional query for filtering the list. Only chats matching this query
- *     are returned. Give NULL for no filtering. When `is:unread` is contained in the query,
- *     the chatlist is filtered such that only chats with unread messages show up.
+ *     are returned. Give NULL for no filtering.
  * @param query_id An optional contact ID for filtering the list. Only chats including this contact ID
  *     are returned. Give 0 for no filtering.
  * @return A chatlist as an dc_chatlist_t object.
@@ -1182,6 +1175,24 @@ int dc_send_webxdc_status_update (dc_context_t* context, uint32_t msg_id, const
  */
 char* dc_get_webxdc_status_updates (dc_context_t* context, uint32_t msg_id, uint32_t serial);
 
+
+/**
+ * Replaces webxdc app with a new version.
+ *
+ * On the JavaScript side this API could be used like this:
+ * ```
+ * window.webxdc.replaceWebxdc(blob);
+ * ```
+ *
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @param msg_id The ID of the WebXDC message to be replaced.
+ * @param blob New blob to replace WebXDC with.
+ * @param n Blob size.
+ */
+void dc_replace_webxdc(dc_context_t* context, uint32_t msg_id, uint8_t *blob, size_t n);
+
+
 /**
  * Save a draft for a chat in the database.
  *
@@ -1488,7 +1499,6 @@ dc_array_t*     dc_get_chat_media            (dc_context_t* context, uint32_t ch
  * Typically used to implement the "next" and "previous" buttons
  * in a gallery or in a media player.
  *
- * @deprecated Deprecated 2023-10-03, use dc_get_chat_media() and navigate the returned array instead.
  * @memberof dc_context_t
  * @param context The context object as returned from dc_context_new().
  * @param msg_id The ID of the current message from which the next or previous message should be searched.
@@ -1718,12 +1728,24 @@ uint32_t        dc_create_group_chat         (dc_context_t* context, int protect
  * Create a new broadcast list.
  *
  * Broadcast lists are similar to groups on the sending device,
- * however, recipients get the messages in a read-only chat
- * and will see who the other members are.
+ * however, recipients get the messages in normal one-to-one chats
+ * and will not be aware of other members.
  *
- * For historical reasons, this function does not take a name directly,
- * instead you have to set the name using dc_set_chat_name()
- * after creating the broadcast list.
+ * Replies to broadcasts go only to the sender
+ * and not to all broadcast recipients.
+ * Moreover, replies will not appear in the broadcast list
+ * but in the one-to-one chat with the person answering.
+ *
+ * The name and the image of the broadcast list is set automatically
+ * and is visible to the sender only.
+ * Not asking for these data allows more focused creation
+ * and we bypass the question who will get which data.
+ * Also, many users will have at most one broadcast list
+ * so, a generic name and image is sufficient at the first place.
+ *
+ * Later on, however, the name can be changed using dc_set_chat_name().
+ * The image cannot be changed to have a unique, recognizable icon in the chat lists.
+ * All in all, this is also what other messengers are doing here.
  *
  * @memberof dc_context_t
  * @param context The context object.
@@ -2266,7 +2288,8 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
  *   the backup is not encrypted.
  *   The backup contains all contacts, chats, images and other data and device independent settings.
  *   The backup does not contain device dependent settings as ringtones or LED notification settings.
- *   The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.tar`.
+ *   The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
+ *   the format is `delta-chat-<day>-<number>.tar`
  *
  * - **DC_IMEX_IMPORT_BACKUP** (12) - `param1` is the file (not: directory) to import. `param2` is the passphrase.
  *   The file is normally created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
@@ -3950,7 +3973,7 @@ int64_t          dc_msg_get_received_timestamp (const dc_msg_t* msg);
  * Get the message time used for sorting.
  * This function returns the timestamp that is used for sorting the message
  * into lists as returned e.g. by dc_get_chat_msgs().
- * This may be the received time, the sending time or another time.
+ * This may be the reveived time, the sending time or another time.
  *
  * To get the receiving time, use dc_msg_get_received_timestamp().
  * To get the sending time, use dc_msg_get_timestamp().
@@ -5042,7 +5065,6 @@ int             dc_contact_is_verified       (dc_contact_t* contact);
  *    A string containing the verifiers address. If it is the same address as the contact itself,
  *    we verified the contact ourself. If it is an empty string, we don't have verifier 
  *    information or the contact is not verified.
- * @deprecated 2023-09-28, use dc_contact_get_verifier_id instead
  */
 char*           dc_contact_get_verifier_addr       (dc_contact_t* contact);
 
@@ -5055,7 +5077,7 @@ char*           dc_contact_get_verifier_addr       (dc_contact_t* contact);
  * @memberof dc_contact_t
  * @param contact The contact object.
  * @return 
- *    The contact ID of the verifier. If it is DC_CONTACT_ID_SELF,
+ *    The `ContactId` of the verifiers address. If it is the same address as the contact itself,
  *    we verified the contact ourself. If it is 0, we don't have verifier information or 
  *    the contact is not verified.
  */
@@ -5751,11 +5773,12 @@ char* dc_jsonrpc_next_response(dc_jsonrpc_instance_t* jsonrpc_instance);
  *
  * @memberof dc_jsonrpc_instance_t
  * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
- * @param input JSON-RPC request.
+ * @param method JSON-RPC method name, e.g. `check_email_validity`.
+ * @param params JSON-RPC method parameters, e.g. `["alice@example.org"]`.
  * @return JSON-RPC response as string, must be freed using dc_str_unref() after usage.
- *     If there is no response, NULL is returned.
+ *     On error, NULL is returned.
  */
-char* dc_jsonrpc_blocking_call(dc_jsonrpc_instance_t* jsonrpc_instance, const char *input);
+char* dc_jsonrpc_blocking_call(dc_jsonrpc_instance_t* jsonrpc_instance, const char *method, const char *params);
 
 /**
  * @class dc_event_emitter_t

deltachat-ffi/src/lib.rs

@@ -29,14 +29,14 @@ use deltachat::contact::{Contact, ContactId, Origin};
 use deltachat::context::Context;
 use deltachat::ephemeral::Timer as EphemeralTimer;
 use deltachat::imex::BackupProvider;
-use deltachat::key::{DcKey, DcSecretKey};
+use deltachat::key::DcKey;
 use deltachat::message::MsgId;
 use deltachat::net::read_url_blob;
 use deltachat::qr_code_generator::{generate_backup_qr, get_securejoin_qr_svg};
 use deltachat::reaction::{get_msg_reactions, send_reaction, Reactions};
 use deltachat::stock_str::StockMessage;
 use deltachat::stock_str::StockStrings;
-use deltachat::webxdc::StatusUpdateSerial;
+use deltachat::webxdc::{replace_webxdc, StatusUpdateSerial};
 use deltachat::*;
 use deltachat::{accounts::Accounts, log::LogExt};
 use num_traits::{FromPrimitive, ToPrimitive};
@@ -805,7 +805,7 @@ pub unsafe extern "C" fn dc_maybe_network(context: *mut dc_context_t) {
 pub unsafe extern "C" fn dc_preconfigure_keypair(
     context: *mut dc_context_t,
     addr: *const libc::c_char,
-    _public_data: *const libc::c_char,
+    public_data: *const libc::c_char,
     secret_data: *const libc::c_char,
 ) -> i32 {
     if context.is_null() {
@@ -815,8 +815,8 @@ pub unsafe extern "C" fn dc_preconfigure_keypair(
     let ctx = &*context;
     block_on(async move {
         let addr = tools::EmailAddress::new(&to_string_lossy(addr))?;
+        let public = key::SignedPublicKey::from_asc(&to_string_lossy(public_data))?.0;
         let secret = key::SignedSecretKey::from_asc(&to_string_lossy(secret_data))?.0;
-        let public = secret.split_public_key()?;
         let keypair = key::KeyPair {
             addr,
             public,
@@ -1097,6 +1097,32 @@ pub unsafe extern "C" fn dc_get_webxdc_status_updates(
     .strdup()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_replace_webxdc(
+    context: *mut dc_context_t,
+    msg_id: u32,
+    blob: *const u8,
+    n: libc::size_t,
+) {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_replace_webxdc()");
+        return;
+    }
+
+    let msg_id = MsgId::new(msg_id);
+    let blob_slice = std::slice::from_raw_parts(blob, n);
+
+    let ctx = &*context;
+
+    block_on(async move {
+        replace_webxdc(ctx, msg_id, blob_slice)
+            .await
+            .context("Failed to replace WebXDC")
+            .log_err(ctx)
+            .ok();
+    })
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_set_draft(
     context: *mut dc_context_t,
@@ -1431,7 +1457,6 @@ pub unsafe extern "C" fn dc_get_chat_media(
 }
 
 #[no_mangle]
-#[allow(deprecated)]
 pub unsafe extern "C" fn dc_get_next_media(
     context: *mut dc_context_t,
     msg_id: u32,
@@ -1540,14 +1565,10 @@ pub unsafe extern "C" fn dc_delete_chat(context: *mut dc_context_t, chat_id: u32
     }
     let ctx = &*context;
 
-    block_on(async move {
-        ChatId::new(chat_id)
-            .delete(ctx)
-            .await
-            .context("Failed chat delete")
-            .log_err(ctx)
-            .ok();
-    })
+    block_on(ChatId::new(chat_id).delete(ctx))
+        .context("Failed chat delete")
+        .log_err(ctx)
+        .ok();
 }
 
 #[no_mangle]
@@ -2568,12 +2589,7 @@ pub unsafe extern "C" fn dc_set_location(
     }
     let ctx = &*context;
 
-    block_on(async move {
-        location::set(ctx, latitude, longitude, accuracy)
-            .await
-            .log_err(ctx)
-            .unwrap_or_default()
-    }) as libc::c_int
+    block_on(location::set(ctx, latitude, longitude, accuracy)) as _
 }
 
 #[no_mangle]
@@ -4537,14 +4553,7 @@ pub unsafe extern "C" fn dc_provider_new_from_email(
 
     let ctx = &*context;
 
-    match block_on(provider::get_provider_info_by_addr(
-        ctx,
-        addr.as_str(),
-        true,
-    ))
-    .log_err(ctx)
-    .unwrap_or_default()
-    {
+    match block_on(provider::get_provider_info(ctx, addr.as_str(), true)) {
         Some(provider) => provider,
         None => ptr::null_mut(),
     }
@@ -4571,14 +4580,11 @@ pub unsafe extern "C" fn dc_provider_new_from_email_with_dns(
 
     match socks5_enabled {
         Ok(socks5_enabled) => {
-            match block_on(provider::get_provider_info_by_addr(
+            match block_on(provider::get_provider_info(
                 ctx,
                 addr.as_str(),
                 socks5_enabled,
-            ))
-            .log_err(ctx)
-            .unwrap_or_default()
-            {
+            )) {
                 Some(provider) => provider,
                 None => ptr::null_mut(),
             }
@@ -5026,7 +5032,7 @@ pub unsafe extern "C" fn dc_accounts_get_event_emitter(
 #[cfg(feature = "jsonrpc")]
 mod jsonrpc {
     use deltachat_jsonrpc::api::CommandApi;
-    use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcSession};
+    use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcServer, RpcSession};
 
     use super::*;
 
@@ -5102,24 +5108,25 @@ mod jsonrpc {
     #[no_mangle]
     pub unsafe extern "C" fn dc_jsonrpc_blocking_call(
         jsonrpc_instance: *mut dc_jsonrpc_instance_t,
-        input: *const libc::c_char,
+        method: *const libc::c_char,
+        params: *const libc::c_char,
     ) -> *mut libc::c_char {
         if jsonrpc_instance.is_null() {
             eprintln!("ignoring careless call to dc_jsonrpc_blocking_call()");
             return ptr::null_mut();
         }
         let api = &*jsonrpc_instance;
-        let input = to_string_lossy(input);
-        let res = block_on(api.handle.process_incoming(&input));
+        let method = to_string_lossy(method);
+        let params = to_string_lossy(params);
+        let params: Option<yerpc::Params> = match serde_json::from_str(&params) {
+            Ok(params) => Some(params),
+            Err(_) => None,
+        };
+        let params = params.map(yerpc::Params::into_value).unwrap_or_default();
+        let res = block_on(api.handle.server().handle_request(method, params));
         match res {
-            Some(message) => {
-                if let Ok(message) = serde_json::to_string(&message) {
-                    message.strdup()
-                } else {
-                    ptr::null_mut()
-                }
-            }
-            None => ptr::null_mut(),
+            Ok(res) => res.to_string().strdup(),
+            Err(_) => ptr::null_mut(),
         }
     }
 }

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.126.1"
+version = "1.122.0"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"

deltachat-jsonrpc/src/api/mod.rs

@@ -812,12 +812,24 @@ impl CommandApi {
     /// Create a new broadcast list.
     ///
     /// Broadcast lists are similar to groups on the sending device,
-    /// however, recipients get the messages in a read-only chat
-    /// and will see who the other members are.
+    /// however, recipients get the messages in normal one-to-one chats
+    /// and will not be aware of other members.
     ///
-    /// For historical reasons, this function does not take a name directly,
-    /// instead you have to set the name using dc_set_chat_name()
-    /// after creating the broadcast list.
+    /// Replies to broadcasts go only to the sender
+    /// and not to all broadcast recipients.
+    /// Moreover, replies will not appear in the broadcast list
+    /// but in the one-to-one chat with the person answering.
+    ///
+    /// The name and the image of the broadcast list is set automatically
+    /// and is visible to the sender only.
+    /// Not asking for these data allows more focused creation
+    /// and we bypass the question who will get which data.
+    /// Also, many users will have at most one broadcast list
+    /// so, a generic name and image is sufficient at the first place.
+    ///
+    /// Later on, however, the name can be changed using dc_set_chat_name().
+    /// The image cannot be changed to have a unique, recognizable icon in the chat lists.
+    /// All in all, this is also what other messengers are doing here.
     async fn create_broadcast_list(&self, account_id: u32) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
         chat::create_broadcast_list(&ctx)
@@ -1415,10 +1427,6 @@ impl CommandApi {
     ///
     /// one combined call for getting chat::get_next_media for both directions
     /// the manual chat::get_next_media in only one direction is not exposed by the jsonrpc yet
-    ///
-    /// Deprecated 2023-10-03, use `get_chat_media` method
-    /// and navigate the returned array instead.
-    #[allow(deprecated)]
     async fn get_neighboring_chat_media(
         &self,
         account_id: u32,
@@ -2053,23 +2061,6 @@ impl CommandApi {
 
         ChatId::new(chat_id).set_draft(&ctx, Some(&mut draft)).await
     }
-
-    // send the chat's current set draft
-    async fn misc_send_draft(&self, account_id: u32, chat_id: u32) -> Result<u32> {
-        let ctx = self.get_context(account_id).await?;
-        if let Some(draft) = ChatId::new(chat_id).get_draft(&ctx).await? {
-            let mut draft = draft;
-            let msg_id = chat::send_msg(&ctx, ChatId::new(chat_id), &mut draft)
-                .await?
-                .to_u32();
-            Ok(msg_id)
-        } else {
-            Err(anyhow!(
-                "chat with id {} doesn't have draft message",
-                chat_id
-            ))
-        }
-    }
 }
 
 // Helper functions (to prevent code duplication)

deltachat-jsonrpc/typescript/package.json

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

deltachat-jsonrpc/typescript/test/online.ts

@@ -148,7 +148,7 @@ describe("online tests", function () {
       waitForEvent(dc, "IncomingMsg", accountId1),
     ]);
     dc.rpc.miscSendTextMessage(accountId2, chatId, "super secret message");
-    // Check if answer arrives at A and if it is encrypted
+    // Check if answer arives at A and if it is encrypted
     await eventPromise2;
 
     const messageId = (

deltachat-repl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.126.1"
+version = "1.122.0"
 license = "MPL-2.0"
 edition = "2021"
 

deltachat-repl/src/cmdline.rs

@@ -138,7 +138,11 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
         /* import a directory */
         let dir_name = std::path::Path::new(&real_spec);
         let dir = fs::read_dir(dir_name).await;
-        if let Ok(mut dir) = dir {
+        if dir.is_err() {
+            error!(context, "Import: Cannot open directory \"{}\".", &real_spec,);
+            return false;
+        } else {
+            let mut dir = dir.unwrap();
             while let Ok(Some(entry)) = dir.next_entry().await {
                 let name_f = entry.file_name();
                 let name = name_f.to_string_lossy();
@@ -150,9 +154,6 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
                     }
                 }
             }
-        } else {
-            error!(context, "Import: Cannot open directory \"{}\".", &real_spec);
-            return false;
         }
     }
     println!("Import: {} items read from \"{}\".", read_cnt, &real_spec);
@@ -893,7 +894,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let latitude = arg1.parse()?;
             let longitude = arg2.parse()?;
 
-            let continue_streaming = location::set(&context, latitude, longitude, 0.).await?;
+            let continue_streaming = location::set(&context, latitude, longitude, 0.).await;
             if continue_streaming {
                 println!("Success, streaming should be continued.");
             } else {

deltachat-rpc-client/README.md

@@ -37,14 +37,19 @@ $ tox --devenv env
 $ . env/bin/activate
 ```
 
+It is recommended to use IPython, because it supports using `await` directly
+from the REPL.
+
 ```
-$ python
->>> from deltachat_rpc_client import *
->>> rpc = Rpc()
->>> rpc.start()
->>> dc = DeltaChat(rpc)
->>> system_info = dc.get_system_info()
->>> system_info["level"]
-'awesome'
->>> rpc.close()
+$ pip install ipython
+$ PATH="../target/debug:$PATH" ipython
+...
+In [1]: from deltachat_rpc_client import *
+In [2]: rpc = Rpc()
+In [3]: await rpc.start()
+In [4]: dc = DeltaChat(rpc)
+In [5]: system_info = await dc.get_system_info()
+In [6]: system_info["level"]
+Out[6]: 'awesome'
+In [7]: await rpc.close()
 ```

deltachat-rpc-client/examples/echobot.py

@@ -4,21 +4,23 @@
 it will echo back any text send to it, it also will print to console all Delta Chat core events.
 Pass --help to the CLI to see available options.
 """
+import asyncio
+
 from deltachat_rpc_client import events, run_bot_cli
 
 hooks = events.HookCollection()
 
 
 @hooks.on(events.RawEvent)
-def log_event(event):
+async def log_event(event):
     print(event)
 
 
 @hooks.on(events.NewMessage)
-def echo(event):
+async def echo(event):
     snapshot = event.message_snapshot
-    snapshot.chat.send_text(snapshot.text)
+    await snapshot.chat.send_text(snapshot.text)
 
 
 if __name__ == "__main__":
-    run_bot_cli(hooks)
+    asyncio.run(run_bot_cli(hooks))

deltachat-rpc-client/examples/echobot_advanced.py

@@ -3,9 +3,9 @@
 
 it will echo back any message that has non-empty text and also supports the /help command.
 """
+import asyncio
 import logging
 import sys
-from threading import Thread
 
 from deltachat_rpc_client import Bot, DeltaChat, EventType, Rpc, events
 
@@ -13,7 +13,7 @@ hooks = events.HookCollection()
 
 
 @hooks.on(events.RawEvent)
-def log_event(event):
+async def log_event(event):
     if event.type == EventType.INFO:
         logging.info(event.msg)
     elif event.type == EventType.WARNING:
@@ -21,54 +21,54 @@ def log_event(event):
 
 
 @hooks.on(events.RawEvent(EventType.ERROR))
-def log_error(event):
+async def log_error(event):
     logging.error(event.msg)
 
 
 @hooks.on(events.MemberListChanged)
-def on_memberlist_changed(event):
+async def on_memberlist_changed(event):
     logging.info("member %s was %s", event.member, "added" if event.member_added else "removed")
 
 
 @hooks.on(events.GroupImageChanged)
-def on_group_image_changed(event):
+async def on_group_image_changed(event):
     logging.info("group image %s", "deleted" if event.image_deleted else "changed")
 
 
 @hooks.on(events.GroupNameChanged)
-def on_group_name_changed(event):
+async def on_group_name_changed(event):
     logging.info("group name changed, old name: %s", event.old_name)
 
 
 @hooks.on(events.NewMessage(func=lambda e: not e.command))
-def echo(event):
+async def echo(event):
     snapshot = event.message_snapshot
     if snapshot.text or snapshot.file:
-        snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
+        await snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
 
 
 @hooks.on(events.NewMessage(command="/help"))
-def help_command(event):
+async def help_command(event):
     snapshot = event.message_snapshot
-    snapshot.chat.send_text("Send me any message and I will echo it back")
+    await snapshot.chat.send_text("Send me any message and I will echo it back")
 
 
-def main():
-    with Rpc() as rpc:
+async def main():
+    async with Rpc() as rpc:
         deltachat = DeltaChat(rpc)
-        system_info = deltachat.get_system_info()
+        system_info = await deltachat.get_system_info()
         logging.info("Running deltachat core %s", system_info.deltachat_core_version)
 
-        accounts = deltachat.get_all_accounts()
-        account = accounts[0] if accounts else deltachat.add_account()
+        accounts = await deltachat.get_all_accounts()
+        account = accounts[0] if accounts else await deltachat.add_account()
 
         bot = Bot(account, hooks)
-        if not bot.is_configured():
-            configure_thread = Thread(run=bot.configure, kwargs={"email": sys.argv[1], "password": sys.argv[2]})
-            configure_thread.start()
-        bot.run_forever()
+        if not await bot.is_configured():
+            # Save a reference to avoid garbage collection of the task.
+            _configure_task = asyncio.create_task(bot.configure(email=sys.argv[1], password=sys.argv[2]))
+        await bot.run_forever()
 
 
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
-    main()
+    asyncio.run(main())

deltachat-rpc-client/examples/echobot_no_hooks.py

@@ -2,44 +2,45 @@
 """
 Example echo bot without using hooks
 """
+import asyncio
 import logging
 import sys
 
 from deltachat_rpc_client import DeltaChat, EventType, Rpc, SpecialContactId
 
 
-def main():
-    with Rpc() as rpc:
+async def main():
+    async with Rpc() as rpc:
         deltachat = DeltaChat(rpc)
-        system_info = deltachat.get_system_info()
+        system_info = await deltachat.get_system_info()
         logging.info("Running deltachat core %s", system_info["deltachat_core_version"])
 
-        accounts = deltachat.get_all_accounts()
-        account = accounts[0] if accounts else deltachat.add_account()
+        accounts = await deltachat.get_all_accounts()
+        account = accounts[0] if accounts else await deltachat.add_account()
 
-        account.set_config("bot", "1")
-        if not account.is_configured():
+        await account.set_config("bot", "1")
+        if not await account.is_configured():
             logging.info("Account is not configured, configuring")
-            account.set_config("addr", sys.argv[1])
-            account.set_config("mail_pw", sys.argv[2])
-            account.configure()
+            await account.set_config("addr", sys.argv[1])
+            await account.set_config("mail_pw", sys.argv[2])
+            await account.configure()
             logging.info("Configured")
         else:
             logging.info("Account is already configured")
-            deltachat.start_io()
+            await deltachat.start_io()
 
-        def process_messages():
-            for message in account.get_next_messages():
-                snapshot = message.get_snapshot()
+        async def process_messages():
+            for message in await account.get_next_messages():
+                snapshot = await message.get_snapshot()
                 if snapshot.from_id != SpecialContactId.SELF and not snapshot.is_bot and not snapshot.is_info:
-                    snapshot.chat.send_text(snapshot.text)
-                snapshot.message.mark_seen()
+                    await snapshot.chat.send_text(snapshot.text)
+                await snapshot.message.mark_seen()
 
         # Process old messages.
-        process_messages()
+        await process_messages()
 
         while True:
-            event = account.wait_for_event()
+            event = await account.wait_for_event()
             if event["type"] == EventType.INFO:
                 logging.info("%s", event["msg"])
             elif event["type"] == EventType.WARNING:
@@ -48,9 +49,9 @@ def main():
                 logging.error("%s", event["msg"])
             elif event["type"] == EventType.INCOMING_MSG:
                 logging.info("Got an incoming message")
-                process_messages()
+                await process_messages()
 
 
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
-    main()
+    asyncio.run(main())

deltachat-rpc-client/pyproject.toml

@@ -5,8 +5,12 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "deltachat-rpc-client"
 description = "Python client for Delta Chat core JSON-RPC interface"
+dependencies = [
+    "aiohttp"
+]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
+    "Framework :: AsyncIO",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
     "Operating System :: POSIX :: Linux",
@@ -71,6 +75,3 @@ line-length = 120
 
 [tool.isort]
 profile = "black"
-
-[tool.pytest.ini_options]
-log_cli = true

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

@@ -1,4 +1,4 @@
-"""Delta Chat JSON-RPC high-level API"""
+"""Delta Chat asynchronous high-level API"""
 from ._utils import AttrDict, run_bot_cli, run_client_cli
 from .account import Account
 from .chat import Chat

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

@@ -1,7 +1,7 @@
 import argparse
+import asyncio
 import re
 import sys
-from threading import Thread
 from typing import TYPE_CHECKING, Callable, Iterable, Optional, Tuple, Type, Union
 
 if TYPE_CHECKING:
@@ -43,7 +43,7 @@ class AttrDict(dict):
         super().__setattr__(attr, val)
 
 
-def run_client_cli(
+async def run_client_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -54,10 +54,10 @@ def run_client_cli(
     """
     from .client import Client
 
-    _run_cli(Client, hooks, argv, **kwargs)
+    await _run_cli(Client, hooks, argv, **kwargs)
 
 
-def run_bot_cli(
+async def run_bot_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -68,10 +68,10 @@ def run_bot_cli(
     """
     from .client import Bot
 
-    _run_cli(Bot, hooks, argv, **kwargs)
+    await _run_cli(Bot, hooks, argv, **kwargs)
 
 
-def _run_cli(
+async def _run_cli(
     client_type: Type["Client"],
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
@@ -93,20 +93,20 @@ def _run_cli(
     parser.add_argument("--password", action="store", help="password")
     args = parser.parse_args(argv[1:])
 
-    with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
+    async with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
         deltachat = DeltaChat(rpc)
-        core_version = (deltachat.get_system_info()).deltachat_core_version
-        accounts = deltachat.get_all_accounts()
-        account = accounts[0] if accounts else deltachat.add_account()
+        core_version = (await deltachat.get_system_info()).deltachat_core_version
+        accounts = await deltachat.get_all_accounts()
+        account = accounts[0] if accounts else await deltachat.add_account()
 
         client = client_type(account, hooks)
         client.logger.debug("Running deltachat core %s", core_version)
-        if not client.is_configured():
+        if not await client.is_configured():
             assert args.email, "Account is not configured and email must be provided"
             assert args.password, "Account is not configured and password must be provided"
-            configure_thread = Thread(run=client.configure, kwargs={"email": args.email, "password": args.password})
-            configure_thread.start()
-        client.run_forever()
+            # Save a reference to avoid garbage collection of the task.
+            _configure_task = asyncio.create_task(client.configure(email=args.email, password=args.password))
+        await client.run_forever()
 
 
 def extract_addr(text: str) -> str:

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

@@ -24,63 +24,63 @@ class Account:
     def _rpc(self) -> "Rpc":
         return self.manager.rpc
 
-    def wait_for_event(self) -> AttrDict:
+    async def wait_for_event(self) -> AttrDict:
         """Wait until the next event and return it."""
-        return AttrDict(self._rpc.wait_for_event(self.id))
+        return AttrDict(await self._rpc.wait_for_event(self.id))
 
-    def remove(self) -> None:
+    async def remove(self) -> None:
         """Remove the account."""
-        self._rpc.remove_account(self.id)
+        await self._rpc.remove_account(self.id)
 
-    def start_io(self) -> None:
+    async def start_io(self) -> None:
         """Start the account I/O."""
-        self._rpc.start_io(self.id)
+        await self._rpc.start_io(self.id)
 
-    def stop_io(self) -> None:
+    async def stop_io(self) -> None:
         """Stop the account I/O."""
-        self._rpc.stop_io(self.id)
+        await self._rpc.stop_io(self.id)
 
-    def get_info(self) -> AttrDict:
+    async def get_info(self) -> AttrDict:
         """Return dictionary of this account configuration parameters."""
-        return AttrDict(self._rpc.get_info(self.id))
+        return AttrDict(await self._rpc.get_info(self.id))
 
-    def get_size(self) -> int:
+    async def get_size(self) -> int:
         """Get the combined filesize of an account in bytes."""
-        return self._rpc.get_account_file_size(self.id)
+        return await self._rpc.get_account_file_size(self.id)
 
-    def is_configured(self) -> bool:
+    async def is_configured(self) -> bool:
         """Return True if this account is configured."""
-        return self._rpc.is_configured(self.id)
+        return await self._rpc.is_configured(self.id)
 
-    def set_config(self, key: str, value: Optional[str] = None) -> None:
+    async def set_config(self, key: str, value: Optional[str] = None) -> None:
         """Set configuration value."""
-        self._rpc.set_config(self.id, key, value)
+        await self._rpc.set_config(self.id, key, value)
 
-    def get_config(self, key: str) -> Optional[str]:
+    async def get_config(self, key: str) -> Optional[str]:
         """Get configuration value."""
-        return self._rpc.get_config(self.id, key)
+        return await self._rpc.get_config(self.id, key)
 
-    def update_config(self, **kwargs) -> None:
+    async def update_config(self, **kwargs) -> None:
         """update config values."""
         for key, value in kwargs.items():
-            self.set_config(key, value)
+            await self.set_config(key, value)
 
-    def set_avatar(self, img_path: Optional[str] = None) -> None:
+    async def set_avatar(self, img_path: Optional[str] = None) -> None:
         """Set self avatar.
 
         Passing None will discard the currently set avatar.
         """
-        self.set_config("selfavatar", img_path)
+        await self.set_config("selfavatar", img_path)
 
-    def get_avatar(self) -> Optional[str]:
+    async def get_avatar(self) -> Optional[str]:
         """Get self avatar."""
-        return self.get_config("selfavatar")
+        return await self.get_config("selfavatar")
 
-    def configure(self) -> None:
+    async def configure(self) -> None:
         """Configure an account."""
-        self._rpc.configure(self.id)
+        await self._rpc.configure(self.id)
 
-    def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
+    async def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
         """Create a new Contact or return an existing one.
 
         Calling this method will always result in the same
@@ -94,24 +94,24 @@ class Account:
         if isinstance(obj, int):
             obj = Contact(self, obj)
         if isinstance(obj, Contact):
-            obj = obj.get_snapshot().address
-        return Contact(self, self._rpc.create_contact(self.id, obj, name))
+            obj = (await obj.get_snapshot()).address
+        return Contact(self, await self._rpc.create_contact(self.id, obj, name))
 
     def get_contact_by_id(self, contact_id: int) -> Contact:
         """Return Contact instance for the given contact ID."""
         return Contact(self, contact_id)
 
-    def get_contact_by_addr(self, address: str) -> Optional[Contact]:
+    async def get_contact_by_addr(self, address: str) -> Optional[Contact]:
         """Check if an e-mail address belongs to a known and unblocked contact."""
-        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
+        contact_id = await self._rpc.lookup_contact_id_by_addr(self.id, address)
         return contact_id and Contact(self, contact_id)
 
-    def get_blocked_contacts(self) -> List[AttrDict]:
+    async def get_blocked_contacts(self) -> List[AttrDict]:
         """Return a list with snapshots of all blocked contacts."""
-        contacts = self._rpc.get_blocked_contacts(self.id)
+        contacts = await self._rpc.get_blocked_contacts(self.id)
         return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
 
-    def get_contacts(
+    async def get_contacts(
         self,
         query: Optional[str] = None,
         with_self: bool = False,
@@ -133,9 +133,9 @@ class Account:
             flags |= ContactFlag.ADD_SELF
 
         if snapshot:
-            contacts = self._rpc.get_contacts(self.id, flags, query)
+            contacts = await self._rpc.get_contacts(self.id, flags, query)
             return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
-        contacts = self._rpc.get_contact_ids(self.id, flags, query)
+        contacts = await self._rpc.get_contact_ids(self.id, flags, query)
         return [Contact(self, contact_id) for contact_id in contacts]
 
     @property
@@ -143,7 +143,7 @@ class Account:
         """This account's identity as a Contact."""
         return Contact(self, SpecialContactId.SELF)
 
-    def get_chatlist(
+    async def get_chatlist(
         self,
         query: Optional[str] = None,
         contact: Optional[Contact] = None,
@@ -175,29 +175,29 @@ class Account:
         if alldone_hint:
             flags |= ChatlistFlag.ADD_ALLDONE_HINT
 
-        entries = self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
+        entries = await self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
         if not snapshot:
             return [Chat(self, entry) for entry in entries]
 
-        items = self._rpc.get_chatlist_items_by_entries(self.id, entries)
+        items = await self._rpc.get_chatlist_items_by_entries(self.id, entries)
         chats = []
         for item in items.values():
             item["chat"] = Chat(self, item["id"])
             chats.append(AttrDict(item))
         return chats
 
-    def create_group(self, name: str, protect: bool = False) -> Chat:
+    async def create_group(self, name: str, protect: bool = False) -> Chat:
         """Create a new group chat.
 
         After creation, the group has only self-contact as member and is in unpromoted state.
         """
-        return Chat(self, self._rpc.create_group_chat(self.id, name, protect))
+        return Chat(self, await self._rpc.create_group_chat(self.id, name, protect))
 
     def get_chat_by_id(self, chat_id: int) -> Chat:
         """Return the Chat instance with the given ID."""
         return Chat(self, chat_id)
 
-    def secure_join(self, qrdata: str) -> Chat:
+    async def secure_join(self, qrdata: str) -> Chat:
         """Continue a Setup-Contact or Verified-Group-Invite protocol started on
         another device.
 
@@ -208,62 +208,62 @@ class Account:
 
         :param qrdata: The text of the scanned QR code.
         """
-        return Chat(self, self._rpc.secure_join(self.id, qrdata))
+        return Chat(self, await self._rpc.secure_join(self.id, qrdata))
 
-    def get_qr_code(self) -> Tuple[str, str]:
+    async def get_qr_code(self) -> Tuple[str, str]:
         """Get Setup-Contact QR Code text and SVG data.
 
         this data needs to be transferred to another Delta Chat account
         in a second channel, typically used by mobiles with QRcode-show + scan UX.
         """
-        return self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
+        return await self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
 
     def get_message_by_id(self, msg_id: int) -> Message:
         """Return the Message instance with the given ID."""
         return Message(self, msg_id)
 
-    def mark_seen_messages(self, messages: List[Message]) -> None:
+    async def mark_seen_messages(self, messages: List[Message]) -> None:
         """Mark the given set of messages as seen."""
-        self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
+        await self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
 
-    def delete_messages(self, messages: List[Message]) -> None:
+    async def delete_messages(self, messages: List[Message]) -> None:
         """Delete messages (local and remote)."""
-        self._rpc.delete_messages(self.id, [msg.id for msg in messages])
+        await self._rpc.delete_messages(self.id, [msg.id for msg in messages])
 
-    def get_fresh_messages(self) -> List[Message]:
+    async def get_fresh_messages(self) -> List[Message]:
         """Return the list of fresh messages, newest messages first.
 
         This call is intended for displaying notifications.
         If you are writing a bot, use `get_fresh_messages_in_arrival_order()` instead,
         to process oldest messages first.
         """
-        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
+        fresh_msg_ids = await self._rpc.get_fresh_msgs(self.id)
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
 
-    def get_next_messages(self) -> List[Message]:
+    async def get_next_messages(self) -> List[Message]:
         """Return a list of next messages."""
-        next_msg_ids = self._rpc.get_next_msgs(self.id)
+        next_msg_ids = await self._rpc.get_next_msgs(self.id)
         return [Message(self, msg_id) for msg_id in next_msg_ids]
 
-    def wait_next_messages(self) -> List[Message]:
+    async def wait_next_messages(self) -> List[Message]:
         """Wait for new messages and return a list of them."""
-        next_msg_ids = self._rpc.wait_next_msgs(self.id)
+        next_msg_ids = await self._rpc.wait_next_msgs(self.id)
         return [Message(self, msg_id) for msg_id in next_msg_ids]
 
-    def get_fresh_messages_in_arrival_order(self) -> List[Message]:
+    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(self._rpc.get_fresh_msgs(self.id))
+        fresh_msg_ids = sorted(await self._rpc.get_fresh_msgs(self.id))
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
 
-    def export_backup(self, path, passphrase: str = "") -> None:
+    async def export_backup(self, path, passphrase: str = "") -> None:
         """Export backup."""
-        self._rpc.export_backup(self.id, str(path), passphrase)
+        await self._rpc.export_backup(self.id, str(path), passphrase)
 
-    def import_backup(self, path, passphrase: str = "") -> None:
+    async def import_backup(self, path, passphrase: str = "") -> None:
         """Import backup."""
-        self._rpc.import_backup(self.id, str(path), passphrase)
+        await self._rpc.import_backup(self.id, str(path), passphrase)

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

@@ -25,7 +25,7 @@ class Chat:
     def _rpc(self) -> "Rpc":
         return self.account._rpc
 
-    def delete(self) -> None:
+    async def delete(self) -> None:
         """Delete this chat and all its messages.
 
         Note:
@@ -33,21 +33,21 @@ class Chat:
         - does not delete messages on server
         - the chat or contact is not blocked, new message will arrive
         """
-        self._rpc.delete_chat(self.account.id, self.id)
+        await self._rpc.delete_chat(self.account.id, self.id)
 
-    def block(self) -> None:
+    async def block(self) -> None:
         """Block this chat."""
-        self._rpc.block_chat(self.account.id, self.id)
+        await self._rpc.block_chat(self.account.id, self.id)
 
-    def accept(self) -> None:
+    async def accept(self) -> None:
         """Accept this contact request chat."""
-        self._rpc.accept_chat(self.account.id, self.id)
+        await self._rpc.accept_chat(self.account.id, self.id)
 
-    def leave(self) -> None:
+    async def leave(self) -> None:
         """Leave this chat."""
-        self._rpc.leave_group(self.account.id, self.id)
+        await self._rpc.leave_group(self.account.id, self.id)
 
-    def mute(self, duration: Optional[int] = None) -> None:
+    async def mute(self, duration: Optional[int] = None) -> None:
         """Mute this chat, if a duration is not provided the chat is muted forever.
 
         :param duration: mute duration from now in seconds. Must be greater than zero.
@@ -57,59 +57,59 @@ class Chat:
             dur: Union[str, dict] = {"Until": duration}
         else:
             dur = "Forever"
-        self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
+        await self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
 
-    def unmute(self) -> None:
+    async def unmute(self) -> None:
         """Unmute this chat."""
-        self._rpc.set_chat_mute_duration(self.account.id, self.id, "NotMuted")
+        await self._rpc.set_chat_mute_duration(self.account.id, self.id, "NotMuted")
 
-    def pin(self) -> None:
+    async def pin(self) -> None:
         """Pin this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
+        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
 
-    def unpin(self) -> None:
+    async def unpin(self) -> None:
         """Unpin this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
 
-    def archive(self) -> None:
+    async def archive(self) -> None:
         """Archive this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
+        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
 
-    def unarchive(self) -> None:
+    async def unarchive(self) -> None:
         """Unarchive this chat."""
-        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
 
-    def set_name(self, name: str) -> None:
+    async def set_name(self, name: str) -> None:
         """Set name of this chat."""
-        self._rpc.set_chat_name(self.account.id, self.id, name)
+        await self._rpc.set_chat_name(self.account.id, self.id, name)
 
-    def set_ephemeral_timer(self, timer: int) -> None:
+    async def set_ephemeral_timer(self, timer: int) -> None:
         """Set ephemeral timer of this chat."""
-        self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
+        await self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
 
-    def get_encryption_info(self) -> str:
+    async def get_encryption_info(self) -> str:
         """Return encryption info for this chat."""
-        return self._rpc.get_chat_encryption_info(self.account.id, self.id)
+        return await self._rpc.get_chat_encryption_info(self.account.id, self.id)
 
-    def get_qr_code(self) -> Tuple[str, str]:
+    async def get_qr_code(self) -> Tuple[str, str]:
         """Get Join-Group QR code text and SVG data."""
-        return self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
+        return await self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
 
-    def get_basic_snapshot(self) -> AttrDict:
+    async def get_basic_snapshot(self) -> AttrDict:
         """Get a chat snapshot with basic info about this chat."""
-        info = self._rpc.get_basic_chat_info(self.account.id, self.id)
+        info = await self._rpc.get_basic_chat_info(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    def get_full_snapshot(self) -> AttrDict:
+    async def get_full_snapshot(self) -> AttrDict:
         """Get a full snapshot of this chat."""
-        info = self._rpc.get_full_chat_by_id(self.account.id, self.id)
+        info = await self._rpc.get_full_chat_by_id(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    def can_send(self) -> bool:
+    async def can_send(self) -> bool:
         """Return true if messages can be sent to the chat."""
-        return self._rpc.can_send(self.account.id, self.id)
+        return await self._rpc.can_send(self.account.id, self.id)
 
-    def send_message(
+    async def send_message(
         self,
         text: Optional[str] = None,
         html: Optional[str] = None,
@@ -132,30 +132,30 @@ class Chat:
             "overrideSenderName": override_sender_name,
             "quotedMessageId": quoted_msg,
         }
-        msg_id = self._rpc.send_msg(self.account.id, self.id, draft)
+        msg_id = await self._rpc.send_msg(self.account.id, self.id, draft)
         return Message(self.account, msg_id)
 
-    def send_text(self, text: str) -> Message:
+    async def send_text(self, text: str) -> Message:
         """Send a text message and return the resulting Message instance."""
-        msg_id = self._rpc.misc_send_text_message(self.account.id, self.id, text)
+        msg_id = await self._rpc.misc_send_text_message(self.account.id, self.id, text)
         return Message(self.account, msg_id)
 
-    def send_videochat_invitation(self) -> Message:
+    async def send_videochat_invitation(self) -> Message:
         """Send a videochat invitation and return the resulting Message instance."""
-        msg_id = self._rpc.send_videochat_invitation(self.account.id, self.id)
+        msg_id = await self._rpc.send_videochat_invitation(self.account.id, self.id)
         return Message(self.account, msg_id)
 
-    def send_sticker(self, path: str) -> Message:
+    async def send_sticker(self, path: str) -> Message:
         """Send an sticker and return the resulting Message instance."""
-        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
+        msg_id = await self._rpc.send_sticker(self.account.id, self.id, path)
         return Message(self.account, msg_id)
 
-    def forward_messages(self, messages: List[Message]) -> None:
+    async def forward_messages(self, messages: List[Message]) -> None:
         """Forward a list of messages to this chat."""
         msg_ids = [msg.id for msg in messages]
-        self._rpc.forward_messages(self.account.id, msg_ids, self.id)
+        await self._rpc.forward_messages(self.account.id, msg_ids, self.id)
 
-    def set_draft(
+    async def set_draft(
         self,
         text: Optional[str] = None,
         file: Optional[str] = None,
@@ -164,15 +164,15 @@ class Chat:
         """Set draft message."""
         if isinstance(quoted_msg, Message):
             quoted_msg = quoted_msg.id
-        self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg)
+        await self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg)
 
-    def remove_draft(self) -> None:
+    async def remove_draft(self) -> None:
         """Remove draft message."""
-        self._rpc.remove_draft(self.account.id, self.id)
+        await self._rpc.remove_draft(self.account.id, self.id)
 
-    def get_draft(self) -> Optional[AttrDict]:
+    async def get_draft(self) -> Optional[AttrDict]:
         """Get draft message."""
-        snapshot = self._rpc.get_draft(self.account.id, self.id)
+        snapshot = await self._rpc.get_draft(self.account.id, self.id)
         if not snapshot:
             return None
         snapshot = AttrDict(snapshot)
@@ -181,61 +181,61 @@ class Chat:
         snapshot["message"] = Message(self.account, snapshot.id)
         return snapshot
 
-    def get_messages(self, info_only: bool = False, add_daymarker: bool = False) -> List[Message]:
+    async def get_messages(self, info_only: bool = False, add_daymarker: bool = False) -> List[Message]:
         """get the list of messages in this chat."""
-        msgs = self._rpc.get_message_ids(self.account.id, self.id, info_only, add_daymarker)
+        msgs = await self._rpc.get_message_ids(self.account.id, self.id, info_only, add_daymarker)
         return [Message(self.account, msg_id) for msg_id in msgs]
 
-    def get_fresh_message_count(self) -> int:
+    async def get_fresh_message_count(self) -> int:
         """Get number of fresh messages in this chat"""
-        return self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
+        return await self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
 
-    def mark_noticed(self) -> None:
+    async def mark_noticed(self) -> None:
         """Mark all messages in this chat as noticed."""
-        self._rpc.marknoticed_chat(self.account.id, self.id)
+        await self._rpc.marknoticed_chat(self.account.id, self.id)
 
-    def add_contact(self, *contact: Union[int, str, Contact]) -> None:
+    async def add_contact(self, *contact: Union[int, str, Contact]) -> None:
         """Add contacts to this group."""
         for cnt in contact:
             if isinstance(cnt, str):
-                contact_id = self.account.create_contact(cnt).id
+                contact_id = (await self.account.create_contact(cnt)).id
             elif not isinstance(cnt, int):
                 contact_id = cnt.id
             else:
                 contact_id = cnt
-            self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)
+            await self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)
 
-    def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
+    async def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
         """Remove members from this group."""
         for cnt in contact:
             if isinstance(cnt, str):
-                contact_id = self.account.create_contact(cnt).id
+                contact_id = (await self.account.create_contact(cnt)).id
             elif not isinstance(cnt, int):
                 contact_id = cnt.id
             else:
                 contact_id = cnt
-            self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)
+            await self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)
 
-    def get_contacts(self) -> List[Contact]:
+    async def get_contacts(self) -> List[Contact]:
         """Get the contacts belonging to this chat.
 
         For single/direct chats self-address is not included.
         """
-        contacts = self._rpc.get_chat_contacts(self.account.id, self.id)
+        contacts = await self._rpc.get_chat_contacts(self.account.id, self.id)
         return [Contact(self.account, contact_id) for contact_id in contacts]
 
-    def set_image(self, path: str) -> None:
+    async def set_image(self, path: str) -> None:
         """Set profile image of this chat.
 
         :param path: Full path of the image to use as the group image.
         """
-        self._rpc.set_chat_profile_image(self.account.id, self.id, path)
+        await self._rpc.set_chat_profile_image(self.account.id, self.id, path)
 
-    def remove_image(self) -> None:
+    async def remove_image(self) -> None:
         """Remove profile image of this chat."""
-        self._rpc.set_chat_profile_image(self.account.id, self.id, None)
+        await self._rpc.set_chat_profile_image(self.account.id, self.id, None)
 
-    def get_locations(
+    async def get_locations(
         self,
         contact: Optional[Contact] = None,
         timestamp_from: Optional["datetime"] = None,
@@ -246,7 +246,7 @@ class Chat:
         time_to = calendar.timegm(timestamp_to.utctimetuple()) if timestamp_to else 0
         contact_id = contact.id if contact else 0
 
-        result = self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
+        result = await self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
         locations = []
         contacts: Dict[int, Contact] = {}
         for loc in result:

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

@@ -1,8 +1,10 @@
 """Event loop implementations offering high level event handling/hooking."""
+import inspect
 import logging
 from typing import (
     TYPE_CHECKING,
     Callable,
+    Coroutine,
     Dict,
     Iterable,
     Optional,
@@ -76,22 +78,22 @@ class Client:
         )
         self._hooks.get(type(event), set()).remove((hook, event))
 
-    def is_configured(self) -> bool:
-        return self.account.is_configured()
+    async def is_configured(self) -> bool:
+        return await self.account.is_configured()
 
-    def configure(self, email: str, password: str, **kwargs) -> None:
-        self.account.set_config("addr", email)
-        self.account.set_config("mail_pw", password)
+    async def configure(self, email: str, password: str, **kwargs) -> None:
+        await self.account.set_config("addr", email)
+        await self.account.set_config("mail_pw", password)
         for key, value in kwargs.items():
-            self.account.set_config(key, value)
-        self.account.configure()
+            await self.account.set_config(key, value)
+        await self.account.configure()
         self.logger.debug("Account configured")
 
-    def run_forever(self) -> None:
+    async def run_forever(self) -> None:
         """Process events forever."""
-        self.run_until(lambda _: False)
+        await self.run_until(lambda _: False)
 
-    def run_until(self, func: Callable[[AttrDict], bool]) -> AttrDict:
+    async def run_until(self, func: Callable[[AttrDict], Union[bool, Coroutine]]) -> AttrDict:
         """Process events until the given callable evaluates to True.
 
         The callable should accept an AttrDict object representing the
@@ -99,37 +101,39 @@ class Client:
         evaluates to True.
         """
         self.logger.debug("Listening to incoming events...")
-        if self.is_configured():
-            self.account.start_io()
-        self._process_messages()  # Process old messages.
+        if await self.is_configured():
+            await self.account.start_io()
+        await self._process_messages()  # Process old messages.
         while True:
-            event = self.account.wait_for_event()
+            event = await self.account.wait_for_event()
             event["type"] = EventType(event.type)
             event["account"] = self.account
-            self._on_event(event)
+            await self._on_event(event)
             if event.type == EventType.INCOMING_MSG:
-                self._process_messages()
+                await self._process_messages()
 
             stop = func(event)
+            if inspect.isawaitable(stop):
+                stop = await stop
             if stop:
                 return event
 
-    def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
+    async def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
         for hook, evfilter in self._hooks.get(filter_type, []):
-            if evfilter.filter(event):
+            if await evfilter.filter(event):
                 try:
-                    hook(event)
+                    await hook(event)
                 except Exception as ex:
                     self.logger.exception(ex)
 
-    def _parse_command(self, event: AttrDict) -> None:
+    async def _parse_command(self, event: AttrDict) -> None:
         cmds = [hook[1].command for hook in self._hooks.get(NewMessage, []) if hook[1].command]
         parts = event.message_snapshot.text.split(maxsplit=1)
         payload = parts[1] if len(parts) > 1 else ""
         cmd = parts.pop(0)
 
         if "@" in cmd:
-            suffix = "@" + self.account.self_contact.get_snapshot().address
+            suffix = "@" + (await self.account.self_contact.get_snapshot()).address
             if cmd.endswith(suffix):
                 cmd = cmd[: -len(suffix)]
             else:
@@ -149,32 +153,32 @@ class Client:
 
         event["command"], event["payload"] = cmd, payload
 
-    def _on_new_msg(self, snapshot: AttrDict) -> None:
+    async def _on_new_msg(self, snapshot: AttrDict) -> None:
         event = AttrDict(command="", payload="", message_snapshot=snapshot)
         if not snapshot.is_info and snapshot.text.startswith(COMMAND_PREFIX):
-            self._parse_command(event)
-        self._on_event(event, NewMessage)
+            await self._parse_command(event)
+        await self._on_event(event, NewMessage)
 
-    def _handle_info_msg(self, snapshot: AttrDict) -> None:
+    async def _handle_info_msg(self, snapshot: AttrDict) -> None:
         event = AttrDict(message_snapshot=snapshot)
 
         img_changed = parse_system_image_changed(snapshot.text)
         if img_changed:
             _, event["image_deleted"] = img_changed
-            self._on_event(event, GroupImageChanged)
+            await self._on_event(event, GroupImageChanged)
             return
 
         title_changed = parse_system_title_changed(snapshot.text)
         if title_changed:
             _, event["old_name"] = title_changed
-            self._on_event(event, GroupNameChanged)
+            await self._on_event(event, GroupNameChanged)
             return
 
         members_changed = parse_system_add_remove(snapshot.text)
         if members_changed:
             action, event["member"], _ = members_changed
             event["member_added"] = action == "added"
-            self._on_event(event, MemberListChanged)
+            await self._on_event(event, MemberListChanged)
             return
 
         self.logger.warning(
@@ -183,20 +187,20 @@ class Client:
             snapshot.text,
         )
 
-    def _process_messages(self) -> None:
+    async def _process_messages(self) -> None:
         if self._should_process_messages:
-            for message in self.account.get_next_messages():
-                snapshot = message.get_snapshot()
+            for message in await self.account.get_next_messages():
+                snapshot = await message.get_snapshot()
                 if snapshot.from_id not in [SpecialContactId.SELF, SpecialContactId.DEVICE]:
-                    self._on_new_msg(snapshot)
+                    await self._on_new_msg(snapshot)
                 if snapshot.is_info and snapshot.system_message_type != SystemMessageType.WEBXDC_INFO_MESSAGE:
-                    self._handle_info_msg(snapshot)
-                snapshot.message.mark_seen()
+                    await self._handle_info_msg(snapshot)
+                await snapshot.message.mark_seen()
 
 
 class Bot(Client):
     """Simple bot implementation that listent to events of a single account."""
 
-    def configure(self, email: str, password: str, **kwargs) -> None:
+    async def configure(self, email: str, password: str, **kwargs) -> None:
         kwargs.setdefault("bot", "1")
-        super().configure(email, password, **kwargs)
+        await super().configure(email, password, **kwargs)

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

@@ -24,39 +24,39 @@ class Contact:
     def _rpc(self) -> "Rpc":
         return self.account._rpc
 
-    def block(self) -> None:
+    async def block(self) -> None:
         """Block contact."""
-        self._rpc.block_contact(self.account.id, self.id)
+        await self._rpc.block_contact(self.account.id, self.id)
 
-    def unblock(self) -> None:
+    async def unblock(self) -> None:
         """Unblock contact."""
-        self._rpc.unblock_contact(self.account.id, self.id)
+        await self._rpc.unblock_contact(self.account.id, self.id)
 
-    def delete(self) -> None:
+    async def delete(self) -> None:
         """Delete contact."""
-        self._rpc.delete_contact(self.account.id, self.id)
+        await self._rpc.delete_contact(self.account.id, self.id)
 
-    def set_name(self, name: str) -> None:
+    async def set_name(self, name: str) -> None:
         """Change the name of this contact."""
-        self._rpc.change_contact_name(self.account.id, self.id, name)
+        await self._rpc.change_contact_name(self.account.id, self.id, name)
 
-    def get_encryption_info(self) -> str:
+    async def get_encryption_info(self) -> str:
         """Get a multi-line encryption info, containing your fingerprint and
         the fingerprint of the contact.
         """
-        return self._rpc.get_contact_encryption_info(self.account.id, self.id)
+        return await self._rpc.get_contact_encryption_info(self.account.id, self.id)
 
-    def get_snapshot(self) -> AttrDict:
+    async def get_snapshot(self) -> AttrDict:
         """Return a dictionary with a snapshot of all contact properties."""
-        snapshot = AttrDict(self._rpc.get_contact(self.account.id, self.id))
+        snapshot = AttrDict(await self._rpc.get_contact(self.account.id, self.id))
         snapshot["contact"] = self
         return snapshot
 
-    def create_chat(self) -> "Chat":
+    async def create_chat(self) -> "Chat":
         """Create or get an existing 1:1 chat for this contact."""
         from .chat import Chat
 
         return Chat(
             self.account,
-            self._rpc.create_chat_by_contact_id(self.account.id, self.id),
+            await self._rpc.create_chat_by_contact_id(self.account.id, self.id),
         )

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

@@ -16,34 +16,34 @@ class DeltaChat:
     def __init__(self, rpc: "Rpc") -> None:
         self.rpc = rpc
 
-    def add_account(self) -> Account:
+    async def add_account(self) -> Account:
         """Create a new account database."""
-        account_id = self.rpc.add_account()
+        account_id = await self.rpc.add_account()
         return Account(self, account_id)
 
-    def get_all_accounts(self) -> List[Account]:
+    async def get_all_accounts(self) -> List[Account]:
         """Return a list of all available accounts."""
-        account_ids = self.rpc.get_all_account_ids()
+        account_ids = await self.rpc.get_all_account_ids()
         return [Account(self, account_id) for account_id in account_ids]
 
-    def start_io(self) -> None:
+    async def start_io(self) -> None:
         """Start the I/O of all accounts."""
-        self.rpc.start_io_for_all_accounts()
+        await self.rpc.start_io_for_all_accounts()
 
-    def stop_io(self) -> None:
+    async def stop_io(self) -> None:
         """Stop the I/O of all accounts."""
-        self.rpc.stop_io_for_all_accounts()
+        await self.rpc.stop_io_for_all_accounts()
 
-    def maybe_network(self) -> None:
+    async def maybe_network(self) -> None:
         """Indicate that the network likely has come back or just that the network
         conditions might have changed.
         """
-        self.rpc.maybe_network()
+        await self.rpc.maybe_network()
 
-    def get_system_info(self) -> AttrDict:
+    async def get_system_info(self) -> AttrDict:
         """Get information about the Delta Chat core in this system."""
-        return AttrDict(self.rpc.get_system_info())
+        return AttrDict(await self.rpc.get_system_info())
 
-    def set_translations(self, translations: Dict[str, str]) -> None:
+    async def set_translations(self, translations: Dict[str, str]) -> None:
         """Set stock translation strings."""
-        self.rpc.set_stock_strings(translations)
+        await self.rpc.set_stock_strings(translations)

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

@@ -1,4 +1,5 @@
 """High-level classes for event processing and filtering."""
+import inspect
 import re
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Optional, Set, Tuple, Union
@@ -23,7 +24,7 @@ def _tuple_of(obj, type_: type) -> tuple:
 class EventFilter(ABC):
     """The base event filter.
 
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -42,13 +43,16 @@ class EventFilter(ABC):
     def __ne__(self, other):
         return not self == other
 
-    def _call_func(self, event) -> bool:
+    async def _call_func(self, event) -> bool:
         if not self.func:
             return True
-        return self.func(event)
+        res = self.func(event)
+        if inspect.isawaitable(res):
+            return await res
+        return res
 
     @abstractmethod
-    def filter(self, event):
+    async def filter(self, event):
         """Return True-like value if the event passed the filter and should be
         used, or False-like value otherwise.
         """
@@ -58,7 +62,7 @@ class RawEvent(EventFilter):
     """Matches raw core events.
 
     :param types: The types of event to match.
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -78,10 +82,10 @@ class RawEvent(EventFilter):
             return (self.types, self.func) == (other.types, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    async def filter(self, event: "AttrDict") -> bool:
         if self.types and event.type not in self.types:
             return False
-        return self._call_func(event)
+        return await self._call_func(event)
 
 
 class NewMessage(EventFilter):
@@ -100,7 +104,7 @@ class NewMessage(EventFilter):
     :param is_info: If set to True only match info/system messages, if set to False
                     only match messages that are not info/system messages. If omitted
                     info/system messages as well as normal messages will be matched.
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -155,7 +159,7 @@ class NewMessage(EventFilter):
             )
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    async def filter(self, event: "AttrDict") -> bool:
         if self.is_bot is not None and self.is_bot != event.message_snapshot.is_bot:
             return False
         if self.is_info is not None and self.is_info != event.message_snapshot.is_info:
@@ -164,9 +168,11 @@ class NewMessage(EventFilter):
             return False
         if self.pattern:
             match = self.pattern(event.message_snapshot.text)
+            if inspect.isawaitable(match):
+                match = await match
             if not match:
                 return False
-        return super()._call_func(event)
+        return await super()._call_func(event)
 
 
 class MemberListChanged(EventFilter):
@@ -178,7 +184,7 @@ class MemberListChanged(EventFilter):
     :param added: If set to True only match if a member was added, if set to False
                   only match if a member was removed. If omitted both, member additions
                   and removals, will be matched.
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -195,10 +201,10 @@ class MemberListChanged(EventFilter):
             return (self.added, self.func) == (other.added, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    async def filter(self, event: "AttrDict") -> bool:
         if self.added is not None and self.added != event.member_added:
             return False
-        return self._call_func(event)
+        return await self._call_func(event)
 
 
 class GroupImageChanged(EventFilter):
@@ -210,7 +216,7 @@ class GroupImageChanged(EventFilter):
     :param deleted: If set to True only match if the image was deleted, if set to False
                     only match if a new image was set. If omitted both, image changes and
                     removals, will be matched.
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -227,10 +233,10 @@ class GroupImageChanged(EventFilter):
             return (self.deleted, self.func) == (other.deleted, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    async def filter(self, event: "AttrDict") -> bool:
         if self.deleted is not None and self.deleted != event.image_deleted:
             return False
-        return self._call_func(event)
+        return await self._call_func(event)
 
 
 class GroupNameChanged(EventFilter):
@@ -239,7 +245,7 @@ class GroupNameChanged(EventFilter):
     Warning: registering a handler for this event will cause the messages
     to be marked as read. Its usage is mainly intended for bots.
 
-    :param func: A Callable function that should accept the event as input
+    :param func: A Callable (async or not) function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -252,8 +258,8 @@ class GroupNameChanged(EventFilter):
             return self.func == other.func
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
-        return self._call_func(event)
+    async def filter(self, event: "AttrDict") -> bool:
+        return await self._call_func(event)
 
 
 class HookCollection:

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

@@ -21,39 +21,39 @@ class Message:
     def _rpc(self) -> "Rpc":
         return self.account._rpc
 
-    def send_reaction(self, *reaction: str):
+    async def send_reaction(self, *reaction: str):
         """Send a reaction to this message."""
-        self._rpc.send_reaction(self.account.id, self.id, reaction)
+        await self._rpc.send_reaction(self.account.id, self.id, reaction)
 
-    def get_snapshot(self) -> AttrDict:
+    async def get_snapshot(self) -> AttrDict:
         """Get a snapshot with the properties of this message."""
         from .chat import Chat
 
-        snapshot = AttrDict(self._rpc.get_message(self.account.id, self.id))
+        snapshot = AttrDict(await self._rpc.get_message(self.account.id, self.id))
         snapshot["chat"] = Chat(self.account, snapshot.chat_id)
         snapshot["sender"] = Contact(self.account, snapshot.from_id)
         snapshot["message"] = self
         return snapshot
 
-    def get_reactions(self) -> Optional[AttrDict]:
+    async def get_reactions(self) -> Optional[AttrDict]:
         """Get message reactions."""
-        reactions = self._rpc.get_message_reactions(self.account.id, self.id)
+        reactions = await self._rpc.get_message_reactions(self.account.id, self.id)
         if reactions:
             return AttrDict(reactions)
         return None
 
-    def mark_seen(self) -> None:
+    async def mark_seen(self) -> None:
         """Mark the message as seen."""
-        self._rpc.markseen_msgs(self.account.id, [self.id])
+        await self._rpc.markseen_msgs(self.account.id, [self.id])
 
-    def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
+    async def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
         """Send a webxdc status update. This message must be a webxdc."""
         if not isinstance(update, str):
             update = json.dumps(update)
-        self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
+        await self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
 
-    def get_webxdc_status_updates(self, last_known_serial: int = 0) -> list:
-        return json.loads(self._rpc.get_webxdc_status_updates(self.account.id, self.id, last_known_serial))
+    async def get_webxdc_status_updates(self, last_known_serial: int = 0) -> list:
+        return json.loads(await self._rpc.get_webxdc_status_updates(self.account.id, self.id, last_known_serial))
 
-    def get_webxdc_info(self) -> dict:
-        return self._rpc.get_webxdc_info(self.account.id, self.id)
+    async def get_webxdc_info(self) -> dict:
+        return await self._rpc.get_webxdc_info(self.account.id, self.id)

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

@@ -1,67 +1,70 @@
+import asyncio
 import json
 import os
-import urllib.request
 from typing import AsyncGenerator, List, Optional
 
-import pytest
+import aiohttp
+import pytest_asyncio
 
 from . import Account, AttrDict, Bot, Client, DeltaChat, EventType, Message
 from .rpc import Rpc
 
 
-def get_temp_credentials() -> dict:
+async def get_temp_credentials() -> dict:
     url = os.getenv("DCC_NEW_TMP_EMAIL")
     assert url, "Failed to get online account, DCC_NEW_TMP_EMAIL is not set"
 
-    request = urllib.request.Request(url, method="POST")
-    with urllib.request.urlopen(request, timeout=60) as f:
-        return json.load(f)
+    # Replace default 5 minute timeout with a 1 minute timeout.
+    timeout = aiohttp.ClientTimeout(total=60)
+    async with aiohttp.ClientSession() as session, session.post(url, timeout=timeout) as response:
+        return json.loads(await response.text())
 
 
 class ACFactory:
     def __init__(self, deltachat: DeltaChat) -> None:
         self.deltachat = deltachat
 
-    def get_unconfigured_account(self) -> Account:
-        return self.deltachat.add_account()
+    async def get_unconfigured_account(self) -> Account:
+        return await self.deltachat.add_account()
 
-    def get_unconfigured_bot(self) -> Bot:
-        return Bot(self.get_unconfigured_account())
+    async def get_unconfigured_bot(self) -> Bot:
+        return Bot(await self.get_unconfigured_account())
 
-    def new_preconfigured_account(self) -> Account:
+    async def new_preconfigured_account(self) -> Account:
         """Make a new account with configuration options set, but configuration not started."""
-        credentials = get_temp_credentials()
-        account = self.get_unconfigured_account()
-        account.set_config("addr", credentials["email"])
-        account.set_config("mail_pw", credentials["password"])
-        assert not account.is_configured()
+        credentials = await get_temp_credentials()
+        account = await self.get_unconfigured_account()
+        await account.set_config("addr", credentials["email"])
+        await account.set_config("mail_pw", credentials["password"])
+        assert not await account.is_configured()
         return account
 
-    def new_configured_account(self) -> Account:
-        account = self.new_preconfigured_account()
-        account.configure()
-        assert account.is_configured()
+    async def new_configured_account(self) -> Account:
+        account = await self.new_preconfigured_account()
+        await account.configure()
+        assert await account.is_configured()
         return account
 
-    def new_configured_bot(self) -> Bot:
-        credentials = get_temp_credentials()
-        bot = self.get_unconfigured_bot()
-        bot.configure(credentials["email"], credentials["password"])
+    async def new_configured_bot(self) -> Bot:
+        credentials = await get_temp_credentials()
+        bot = await self.get_unconfigured_bot()
+        await bot.configure(credentials["email"], credentials["password"])
         return bot
 
-    def get_online_account(self) -> Account:
-        account = self.new_configured_account()
-        account.start_io()
+    async def get_online_account(self) -> Account:
+        account = await self.new_configured_account()
+        await account.start_io()
         while True:
-            event = account.wait_for_event()
+            event = await account.wait_for_event()
+            print(event)
             if event.type == EventType.IMAP_INBOX_IDLE:
                 break
         return account
 
-    def get_online_accounts(self, num: int) -> List[Account]:
-        return [self.get_online_account() for _ in range(num)]
+    async def get_online_accounts(self, num: int) -> List[Account]:
+        return await asyncio.gather(*[self.get_online_account() for _ in range(num)])
 
-    def send_message(
+    async def send_message(
         self,
         to_account: Account,
         from_account: Optional[Account] = None,
@@ -70,16 +73,16 @@ class ACFactory:
         group: Optional[str] = None,
     ) -> Message:
         if not from_account:
-            from_account = (self.get_online_accounts(1))[0]
-        to_contact = from_account.create_contact(to_account.get_config("addr"))
+            from_account = (await self.get_online_accounts(1))[0]
+        to_contact = await from_account.create_contact(await to_account.get_config("addr"))
         if group:
-            to_chat = from_account.create_group(group)
-            to_chat.add_contact(to_contact)
+            to_chat = await from_account.create_group(group)
+            await to_chat.add_contact(to_contact)
         else:
-            to_chat = to_contact.create_chat()
-        return to_chat.send_message(text=text, file=file)
+            to_chat = await to_contact.create_chat()
+        return await to_chat.send_message(text=text, file=file)
 
-    def process_message(
+    async def process_message(
         self,
         to_client: Client,
         from_account: Optional[Account] = None,
@@ -87,7 +90,7 @@ class ACFactory:
         file: Optional[str] = None,
         group: Optional[str] = None,
     ) -> AttrDict:
-        self.send_message(
+        await self.send_message(
             to_account=to_client.account,
             from_account=from_account,
             text=text,
@@ -95,16 +98,16 @@ class ACFactory:
             group=group,
         )
 
-        return to_client.run_until(lambda e: e.type == EventType.INCOMING_MSG)
+        return await to_client.run_until(lambda e: e.type == EventType.INCOMING_MSG)
 
 
-@pytest.fixture()
-def rpc(tmp_path) -> AsyncGenerator:
+@pytest_asyncio.fixture
+async def rpc(tmp_path) -> AsyncGenerator:
     rpc_server = Rpc(accounts_dir=str(tmp_path / "accounts"))
-    with rpc_server:
+    async with rpc_server:
         yield rpc_server
 
 
-@pytest.fixture()
-def acfactory(rpc) -> AsyncGenerator:
-    return ACFactory(DeltaChat(rpc))
+@pytest_asyncio.fixture
+async def acfactory(rpc) -> AsyncGenerator:
+    yield ACFactory(DeltaChat(rpc))

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

@@ -1,10 +1,6 @@
+import asyncio
 import json
-import logging
 import os
-import subprocess
-import sys
-from queue import Queue
-from threading import Event, Thread
 from typing import Any, Dict, Optional
 
 
@@ -14,7 +10,7 @@ class JsonRpcError(Exception):
 
 class Rpc:
     def __init__(self, accounts_dir: Optional[str] = None, **kwargs):
-        """The given arguments will be passed to subprocess.Popen()"""
+        """The given arguments will be passed to asyncio.create_subprocess_exec()"""
         if accounts_dir:
             kwargs["env"] = {
                 **kwargs.get("env", os.environ),
@@ -22,127 +18,78 @@ class Rpc:
             }
 
         self._kwargs = kwargs
-        self.process: subprocess.Popen
+        self.process: asyncio.subprocess.Process
         self.id: int
-        self.event_queues: Dict[int, Queue]
-        # Map from request ID to `threading.Event`.
-        self.request_events: Dict[int, Event]
-        # Map from request ID to the result.
-        self.request_results: Dict[int, Any]
-        self.request_queue: Queue[Any]
+        self.event_queues: Dict[int, asyncio.Queue]
+        # Map from request ID to `asyncio.Future` returning the response.
+        self.request_events: Dict[int, asyncio.Future]
         self.closing: bool
-        self.reader_thread: Thread
-        self.writer_thread: Thread
-        self.events_thread: Thread
+        self.reader_task: asyncio.Task
+        self.events_task: asyncio.Task
 
-    def start(self) -> None:
-        if sys.version_info >= (3, 11):
-            self.process = subprocess.Popen(
-                "deltachat-rpc-server",
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                # Prevent subprocess from capturing SIGINT.
-                process_group=0,
-                **self._kwargs,
-            )
-        else:
-            self.process = subprocess.Popen(
-                "deltachat-rpc-server",
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                # `process_group` is not supported before Python 3.11.
-                preexec_fn=os.setpgrp,  # noqa: PLW1509
-                **self._kwargs,
-            )
+    async def start(self) -> None:
+        self.process = await asyncio.create_subprocess_exec(
+            "deltachat-rpc-server",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            **self._kwargs,
+        )
         self.id = 0
         self.event_queues = {}
         self.request_events = {}
-        self.request_results = {}
-        self.request_queue = Queue()
         self.closing = False
-        self.reader_thread = Thread(target=self.reader_loop)
-        self.reader_thread.start()
-        self.writer_thread = Thread(target=self.writer_loop)
-        self.writer_thread.start()
-        self.events_thread = Thread(target=self.events_loop)
-        self.events_thread.start()
+        self.reader_task = asyncio.create_task(self.reader_loop())
+        self.events_task = asyncio.create_task(self.events_loop())
 
-    def close(self) -> None:
+    async def close(self) -> None:
         """Terminate RPC server process and wait until the reader loop finishes."""
         self.closing = True
-        self.stop_io_for_all_accounts()
-        self.events_thread.join()
-        self.process.stdin.close()
-        self.reader_thread.join()
-        self.request_queue.put(None)
-        self.writer_thread.join()
+        await self.stop_io_for_all_accounts()
+        await self.events_task
+        self.process.terminate()
+        await self.reader_task
 
-    def __enter__(self):
-        self.start()
+    async def __aenter__(self):
+        await self.start()
         return self
 
-    def __exit__(self, _exc_type, _exc, _tb):
-        self.close()
+    async def __aexit__(self, _exc_type, _exc, _tb):
+        await self.close()
 
-    def reader_loop(self) -> None:
-        try:
-            while True:
-                line = self.process.stdout.readline()
-                if not line:  # EOF
-                    break
-                response = json.loads(line)
-                if "id" in response:
-                    response_id = response["id"]
-                    event = self.request_events.pop(response_id)
-                    self.request_results[response_id] = response
-                    event.set()
-                else:
-                    logging.warning("Got a response without ID: %s", response)
-        except Exception:
-            # Log an exception if the reader loop dies.
-            logging.exception("Exception in the reader loop")
+    async def reader_loop(self) -> None:
+        while True:
+            line = await self.process.stdout.readline()  # noqa
+            if not line:  # EOF
+                break
+            response = json.loads(line)
+            if "id" in response:
+                fut = self.request_events.pop(response["id"])
+                fut.set_result(response)
+            else:
+                print(response)
 
-    def writer_loop(self) -> None:
-        """Writer loop ensuring only a single thread writes requests."""
-        try:
-            while True:
-                request = self.request_queue.get()
-                if not request:
-                    break
-                data = (json.dumps(request) + "\n").encode()
-                self.process.stdin.write(data)
-                self.process.stdin.flush()
-
-        except Exception:
-            # Log an exception if the writer loop dies.
-            logging.exception("Exception in the writer loop")
-
-    def get_queue(self, account_id: int) -> Queue:
+    async def get_queue(self, account_id: int) -> asyncio.Queue:
         if account_id not in self.event_queues:
-            self.event_queues[account_id] = Queue()
+            self.event_queues[account_id] = asyncio.Queue()
         return self.event_queues[account_id]
 
-    def events_loop(self) -> None:
+    async def events_loop(self) -> None:
         """Requests new events and distributes them between queues."""
-        try:
-            while True:
-                if self.closing:
-                    return
-                event = self.get_next_event()
-                account_id = event["contextId"]
-                queue = self.get_queue(account_id)
-                queue.put(event["event"])
-        except Exception:
-            # Log an exception if the event loop dies.
-            logging.exception("Exception in the event loop")
+        while True:
+            if self.closing:
+                return
+            event = await self.get_next_event()
+            account_id = event["contextId"]
+            queue = await self.get_queue(account_id)
+            await queue.put(event["event"])
 
-    def wait_for_event(self, account_id: int) -> Optional[dict]:
+    async def wait_for_event(self, account_id: int) -> Optional[dict]:
         """Waits for the next event from the given account and returns it."""
-        queue = self.get_queue(account_id)
-        return queue.get()
+        queue = await self.get_queue(account_id)
+        return await queue.get()
 
     def __getattr__(self, attr: str):
-        def method(*args) -> Any:
+        async def method(*args) -> Any:
             self.id += 1
             request_id = self.id
 
@@ -152,12 +99,12 @@ class Rpc:
                 "params": args,
                 "id": self.id,
             }
-            event = Event()
-            self.request_events[request_id] = event
-            self.request_queue.put(request)
-            event.wait()
-
-            response = self.request_results.pop(request_id)
+            data = (json.dumps(request) + "\n").encode()
+            self.process.stdin.write(data)  # noqa
+            loop = asyncio.get_running_loop()
+            fut = loop.create_future()
+            self.request_events[request_id] = fut
+            response = await fut
             if "error" in response:
                 raise JsonRpcError(response["error"])
             if "result" in response:

deltachat-rpc-client/tests/test_something.py

@@ -1,4 +1,4 @@
-import concurrent.futures
+import asyncio
 from unittest.mock import MagicMock
 
 import pytest
@@ -6,26 +6,26 @@ from deltachat_rpc_client import EventType, events
 from deltachat_rpc_client.rpc import JsonRpcError
 
 
-def test_system_info(rpc) -> None:
-    system_info = rpc.get_system_info()
+@pytest.mark.asyncio()
+async def test_system_info(rpc) -> None:
+    system_info = await rpc.get_system_info()
     assert "arch" in system_info
     assert "deltachat_core_version" in system_info
 
 
-def test_sleep(rpc) -> None:
+@pytest.mark.asyncio()
+async def test_sleep(rpc) -> None:
     """Test that long-running task does not block short-running task from completion."""
-    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
-        sleep_5_future = executor.submit(rpc.sleep, 5.0)
-        sleep_3_future = executor.submit(rpc.sleep, 3.0)
-        done, pending = concurrent.futures.wait(
-            [sleep_5_future, sleep_3_future],
-            return_when=concurrent.futures.FIRST_COMPLETED,
-        )
-        assert sleep_3_future in done
-        assert sleep_5_future in pending
+    sleep_5_task = asyncio.create_task(rpc.sleep(5.0))
+    sleep_3_task = asyncio.create_task(rpc.sleep(3.0))
+    done, pending = await asyncio.wait([sleep_5_task, sleep_3_task], return_when=asyncio.FIRST_COMPLETED)
+    assert sleep_3_task in done
+    assert sleep_5_task in pending
+    sleep_5_task.cancel()
 
 
-def test_email_address_validity(rpc) -> None:
+@pytest.mark.asyncio()
+async def test_email_address_validity(rpc) -> None:
     valid_addresses = [
         "email@example.com",
         "36aa165ae3406424e0c61af17700f397cad3fe8ab83d682d0bddf3338a5dd52e@yggmail@yggmail",
@@ -33,15 +33,16 @@ def test_email_address_validity(rpc) -> None:
     invalid_addresses = ["email@", "example.com", "emai221"]
 
     for addr in valid_addresses:
-        assert rpc.check_email_validity(addr)
+        assert await rpc.check_email_validity(addr)
     for addr in invalid_addresses:
-        assert not rpc.check_email_validity(addr)
+        assert not await rpc.check_email_validity(addr)
 
 
-def test_acfactory(acfactory) -> None:
-    account = acfactory.new_configured_account()
+@pytest.mark.asyncio()
+async def test_acfactory(acfactory) -> None:
+    account = await acfactory.new_configured_account()
     while True:
-        event = account.wait_for_event()
+        event = await account.wait_for_event()
         if event.type == EventType.CONFIGURE_PROGRESS:
             assert event.progress != 0  # Progress 0 indicates error.
             if event.progress == 1000:  # Success
@@ -51,241 +52,248 @@ def test_acfactory(acfactory) -> None:
     print("Successful configuration")
 
 
-def test_configure_starttls(acfactory) -> None:
-    account = acfactory.new_preconfigured_account()
+@pytest.mark.asyncio()
+async def test_configure_starttls(acfactory) -> None:
+    account = await acfactory.new_preconfigured_account()
 
     # Use STARTTLS
-    account.set_config("mail_security", "2")
-    account.set_config("send_security", "2")
-    account.configure()
-    assert account.is_configured()
+    await account.set_config("mail_security", "2")
+    await account.set_config("send_security", "2")
+    await account.configure()
+    assert await account.is_configured()
 
 
-def test_account(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio()
+async def test_account(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_text("Hello!")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = bob.wait_for_event()
+        event = await bob.wait_for_event()
         if event.type == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
     message = bob.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
+    snapshot = await message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
-    bob.mark_seen_messages([message])
+    await bob.mark_seen_messages([message])
 
     assert alice != bob
     assert repr(alice)
-    assert alice.get_info().level
-    assert alice.get_size()
-    assert alice.is_configured()
-    assert not alice.get_avatar()
-    assert alice.get_contact_by_addr(bob_addr) == alice_contact_bob
-    assert alice.get_contacts()
-    assert alice.get_contacts(snapshot=True)
+    assert (await alice.get_info()).level
+    assert await alice.get_size()
+    assert await alice.is_configured()
+    assert not await alice.get_avatar()
+    assert await alice.get_contact_by_addr(bob_addr) == alice_contact_bob
+    assert await alice.get_contacts()
+    assert await alice.get_contacts(snapshot=True)
     assert alice.self_contact
-    assert alice.get_chatlist()
-    assert alice.get_chatlist(snapshot=True)
-    assert alice.get_qr_code()
-    assert alice.get_fresh_messages()
-    assert alice.get_next_messages()
+    assert await alice.get_chatlist()
+    assert await alice.get_chatlist(snapshot=True)
+    assert await alice.get_qr_code()
+    assert await alice.get_fresh_messages()
+    assert await alice.get_next_messages()
 
     # Test sending empty message.
-    assert len(bob.wait_next_messages()) == 0
-    alice_chat_bob.send_text("")
-    messages = bob.wait_next_messages()
+    assert len(await bob.wait_next_messages()) == 0
+    await alice_chat_bob.send_text("")
+    messages = await bob.wait_next_messages()
     assert len(messages) == 1
     message = messages[0]
-    snapshot = message.get_snapshot()
+    snapshot = await message.get_snapshot()
     assert snapshot.text == ""
-    bob.mark_seen_messages([message])
+    await bob.mark_seen_messages([message])
 
-    group = alice.create_group("test group")
-    group.add_contact(alice_contact_bob)
-    group_msg = group.send_message(text="hello")
+    group = await alice.create_group("test group")
+    await group.add_contact(alice_contact_bob)
+    group_msg = await group.send_message(text="hello")
     assert group_msg == alice.get_message_by_id(group_msg.id)
     assert group == alice.get_chat_by_id(group.id)
-    alice.delete_messages([group_msg])
+    await alice.delete_messages([group_msg])
 
-    alice.set_config("selfstatus", "test")
-    assert alice.get_config("selfstatus") == "test"
-    alice.update_config(selfstatus="test2")
-    assert alice.get_config("selfstatus") == "test2"
+    await alice.set_config("selfstatus", "test")
+    assert await alice.get_config("selfstatus") == "test"
+    await alice.update_config(selfstatus="test2")
+    assert await alice.get_config("selfstatus") == "test2"
 
-    assert not alice.get_blocked_contacts()
-    alice_contact_bob.block()
-    blocked_contacts = alice.get_blocked_contacts()
+    assert not await alice.get_blocked_contacts()
+    await alice_contact_bob.block()
+    blocked_contacts = await alice.get_blocked_contacts()
     assert blocked_contacts
     assert blocked_contacts[0].contact == alice_contact_bob
 
-    bob.remove()
-    alice.stop_io()
+    await bob.remove()
+    await alice.stop_io()
 
 
-def test_chat(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio()
+async def test_chat(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_text("Hello!")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = bob.wait_for_event()
+        event = await bob.wait_for_event()
         if event.type == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
     message = bob.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
+    snapshot = await message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
     bob_chat_alice = bob.get_chat_by_id(chat_id)
 
     assert alice_chat_bob != bob_chat_alice
     assert repr(alice_chat_bob)
-    alice_chat_bob.delete()
-    assert not bob_chat_alice.can_send()
-    bob_chat_alice.accept()
-    assert bob_chat_alice.can_send()
-    bob_chat_alice.block()
-    bob_chat_alice = snapshot.sender.create_chat()
-    bob_chat_alice.mute()
-    bob_chat_alice.unmute()
-    bob_chat_alice.pin()
-    bob_chat_alice.unpin()
-    bob_chat_alice.archive()
-    bob_chat_alice.unarchive()
+    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()
+    await bob_chat_alice.unmute()
+    await bob_chat_alice.pin()
+    await bob_chat_alice.unpin()
+    await bob_chat_alice.archive()
+    await bob_chat_alice.unarchive()
     with pytest.raises(JsonRpcError):  # can't set name for 1:1 chats
-        bob_chat_alice.set_name("test")
-    bob_chat_alice.set_ephemeral_timer(300)
-    bob_chat_alice.get_encryption_info()
+        await bob_chat_alice.set_name("test")
+    await bob_chat_alice.set_ephemeral_timer(300)
+    await bob_chat_alice.get_encryption_info()
 
-    group = alice.create_group("test group")
-    group.add_contact(alice_contact_bob)
-    group.get_qr_code()
+    group = await alice.create_group("test group")
+    await group.add_contact(alice_contact_bob)
+    await group.get_qr_code()
 
-    snapshot = group.get_basic_snapshot()
+    snapshot = await group.get_basic_snapshot()
     assert snapshot.name == "test group"
-    group.set_name("new name")
-    snapshot = group.get_full_snapshot()
+    await group.set_name("new name")
+    snapshot = await group.get_full_snapshot()
     assert snapshot.name == "new name"
 
-    msg = group.send_message(text="hi")
-    assert (msg.get_snapshot()).text == "hi"
-    group.forward_messages([msg])
+    msg = await group.send_message(text="hi")
+    assert (await msg.get_snapshot()).text == "hi"
+    await group.forward_messages([msg])
 
-    group.set_draft(text="test draft")
-    draft = group.get_draft()
+    await group.set_draft(text="test draft")
+    draft = await group.get_draft()
     assert draft.text == "test draft"
-    group.remove_draft()
-    assert not group.get_draft()
+    await group.remove_draft()
+    assert not await group.get_draft()
 
-    assert group.get_messages()
-    group.get_fresh_message_count()
-    group.mark_noticed()
-    assert group.get_contacts()
-    group.remove_contact(alice_chat_bob)
-    group.get_locations()
+    assert await group.get_messages()
+    await group.get_fresh_message_count()
+    await group.mark_noticed()
+    assert await group.get_contacts()
+    await group.remove_contact(alice_chat_bob)
+    await group.get_locations()
 
 
-def test_contact(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio()
+async def test_contact(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
 
     assert alice_contact_bob == alice.get_contact_by_id(alice_contact_bob.id)
     assert repr(alice_contact_bob)
-    alice_contact_bob.block()
-    alice_contact_bob.unblock()
-    alice_contact_bob.set_name("new name")
-    alice_contact_bob.get_encryption_info()
-    snapshot = alice_contact_bob.get_snapshot()
+    await alice_contact_bob.block()
+    await alice_contact_bob.unblock()
+    await alice_contact_bob.set_name("new name")
+    await alice_contact_bob.get_encryption_info()
+    snapshot = await alice_contact_bob.get_snapshot()
     assert snapshot.address == bob_addr
-    alice_contact_bob.create_chat()
+    await alice_contact_bob.create_chat()
 
 
-def test_message(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio()
+async def test_message(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_text("Hello!")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = bob.wait_for_event()
+        event = await bob.wait_for_event()
         if event.type == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
     message = bob.get_message_by_id(msg_id)
-    snapshot = message.get_snapshot()
+    snapshot = await message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
     assert not snapshot.is_bot
     assert repr(message)
 
     with pytest.raises(JsonRpcError):  # chat is not accepted
-        snapshot.chat.send_text("hi")
-    snapshot.chat.accept()
-    snapshot.chat.send_text("hi")
+        await snapshot.chat.send_text("hi")
+    await snapshot.chat.accept()
+    await snapshot.chat.send_text("hi")
 
-    message.mark_seen()
-    message.send_reaction("😎")
-    reactions = message.get_reactions()
+    await message.mark_seen()
+    await message.send_reaction("😎")
+    reactions = await message.get_reactions()
     assert reactions
-    snapshot = message.get_snapshot()
+    snapshot = await message.get_snapshot()
     assert reactions == snapshot.reactions
 
 
-def test_is_bot(acfactory) -> None:
+@pytest.mark.asyncio()
+async def test_is_bot(acfactory) -> None:
     """Test that we can recognize messages submitted by bots."""
-    alice, bob = acfactory.get_online_accounts(2)
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
 
     # Alice becomes a bot.
-    alice.set_config("bot", "1")
-    alice_chat_bob.send_text("Hello!")
+    await alice.set_config("bot", "1")
+    await alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = bob.wait_for_event()
+        event = await bob.wait_for_event()
         if event.type == EventType.INCOMING_MSG:
             msg_id = event.msg_id
             message = bob.get_message_by_id(msg_id)
-            snapshot = message.get_snapshot()
+            snapshot = await message.get_snapshot()
             assert snapshot.chat_id == event.chat_id
             assert snapshot.text == "Hello!"
             assert snapshot.is_bot
             break
 
 
-def test_bot(acfactory) -> None:
+@pytest.mark.asyncio()
+async def test_bot(acfactory) -> None:
     mock = MagicMock()
-    user = (acfactory.get_online_accounts(1))[0]
-    bot = acfactory.new_configured_bot()
-    bot2 = acfactory.new_configured_bot()
+    user = (await acfactory.get_online_accounts(1))[0]
+    bot = await acfactory.new_configured_bot()
+    bot2 = await acfactory.new_configured_bot()
 
-    assert bot.is_configured()
-    assert bot.account.get_config("bot") == "1"
+    assert await bot.is_configured()
+    assert await bot.account.get_config("bot") == "1"
 
     hook = lambda e: mock.hook(e.msg_id) and None, events.RawEvent(EventType.INCOMING_MSG)
     bot.add_hook(*hook)
-    event = acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
-    snapshot = bot.account.get_message_by_id(event.msg_id).get_snapshot()
+    event = await acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
+    snapshot = await bot.account.get_message_by_id(event.msg_id).get_snapshot()
     assert not snapshot.is_bot
     mock.hook.assert_called_once_with(event.msg_id)
     bot.remove_hook(*hook)
@@ -297,52 +305,53 @@ def test_bot(acfactory) -> None:
     hook = track, events.NewMessage(r"hello")
     bot.add_hook(*hook)
     bot.add_hook(track, events.NewMessage(command="/help"))
-    event = acfactory.process_message(from_account=user, to_client=bot, text="hello")
+    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello")
     mock.hook.assert_called_with(event.msg_id)
-    event = acfactory.process_message(from_account=user, to_client=bot, text="hello!")
+    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello!")
     mock.hook.assert_called_with(event.msg_id)
-    acfactory.process_message(from_account=bot2.account, to_client=bot, text="hello")
+    await acfactory.process_message(from_account=bot2.account, to_client=bot, text="hello")
     assert len(mock.hook.mock_calls) == 2  # bot messages are ignored between bots
-    acfactory.process_message(from_account=user, to_client=bot, text="hey!")
+    await acfactory.process_message(from_account=user, to_client=bot, text="hey!")
     assert len(mock.hook.mock_calls) == 2
     bot.remove_hook(*hook)
 
     mock.hook.reset_mock()
-    acfactory.process_message(from_account=user, to_client=bot, text="hello")
-    event = acfactory.process_message(from_account=user, to_client=bot, text="/help")
+    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)
 
 
-def test_wait_next_messages(acfactory) -> None:
-    alice = acfactory.new_configured_account()
+@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 = acfactory.new_preconfigured_account()
-    bot.set_config("bot", "1")
-    bot.configure()
+    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 bot.wait_next_messages()
+    assert not await bot.wait_next_messages()
 
-    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
-        # Bot starts waiting for messages.
-        next_messages_task = executor.submit(bot.wait_next_messages)
+    # Bot starts waiting for messages.
+    next_messages_task = asyncio.create_task(bot.wait_next_messages())
 
-        bot_addr = bot.get_config("addr")
-        alice_contact_bot = alice.create_contact(bot_addr, "Bob")
-        alice_chat_bot = alice_contact_bot.create_chat()
-        alice_chat_bot.send_text("Hello!")
+    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 = next_messages_task.result()
-        assert len(next_messages) == 1
-        snapshot = next_messages[0].get_snapshot()
-        assert snapshot.text == "Hello!"
+    next_messages = await next_messages_task
+    assert len(next_messages) == 1
+    snapshot = await next_messages[0].get_snapshot()
+    assert snapshot.text == "Hello!"
 
 
-def test_import_export(acfactory, tmp_path) -> None:
-    alice = acfactory.new_configured_account()
-    alice.export_backup(tmp_path)
+@pytest.mark.asyncio()
+async def test_import_export(acfactory, tmp_path) -> None:
+    alice = await acfactory.new_configured_account()
+    await alice.export_backup(tmp_path)
 
     files = list(tmp_path.glob("*.tar"))
-    alice2 = acfactory.get_unconfigured_account()
-    alice2.import_backup(files[0])
+    alice2 = await acfactory.get_unconfigured_account()
+    await alice2.import_backup(files[0])

deltachat-rpc-client/tests/test_webxdc.py

@@ -1,22 +1,24 @@
+import pytest
 from deltachat_rpc_client import EventType
 
 
-def test_webxdc(acfactory) -> None:
-    alice, bob = acfactory.get_online_accounts(2)
+@pytest.mark.asyncio()
+async def test_webxdc(acfactory) -> None:
+    alice, bob = await acfactory.get_online_accounts(2)
 
-    bob_addr = bob.get_config("addr")
-    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
-    alice_chat_bob = alice_contact_bob.create_chat()
-    alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")
+    bob_addr = await bob.get_config("addr")
+    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")
 
     while True:
-        event = bob.wait_for_event()
+        event = await bob.wait_for_event()
         if event.type == EventType.INCOMING_MSG:
             bob_chat_alice = bob.get_chat_by_id(event.chat_id)
             message = bob.get_message_by_id(event.msg_id)
             break
 
-    webxdc_info = message.get_webxdc_info()
+    webxdc_info = await message.get_webxdc_info()
     assert webxdc_info == {
         "document": None,
         "icon": "icon.png",
@@ -26,20 +28,20 @@ def test_webxdc(acfactory) -> None:
         "summary": None,
     }
 
-    status_updates = message.get_webxdc_status_updates()
+    status_updates = await message.get_webxdc_status_updates()
     assert status_updates == []
 
-    bob_chat_alice.accept()
-    message.send_webxdc_status_update({"payload": 42}, "")
-    message.send_webxdc_status_update({"payload": "Second update"}, "description")
+    await bob_chat_alice.accept()
+    await message.send_webxdc_status_update({"payload": 42}, "")
+    await message.send_webxdc_status_update({"payload": "Second update"}, "description")
 
-    status_updates = message.get_webxdc_status_updates()
+    status_updates = await message.get_webxdc_status_updates()
     assert status_updates == [
         {"payload": 42, "serial": 1, "max_serial": 2},
         {"payload": "Second update", "serial": 2, "max_serial": 2},
     ]
 
-    status_updates = message.get_webxdc_status_updates(1)
+    status_updates = await message.get_webxdc_status_updates(1)
     assert status_updates == [
         {"payload": "Second update", "serial": 2, "max_serial": 2},
     ]

deltachat-rpc-client/tox.ini

@@ -6,7 +6,7 @@ envlist =
 
 [testenv]
 commands =
-    pytest -n6 {posargs}
+    pytest {posargs}
 setenv =
 # Avoid stack overflow when Rust core is built without optimizations.
     RUST_MIN_STACK=8388608
@@ -14,8 +14,10 @@ passenv =
     DCC_NEW_TMP_EMAIL
 deps =
     pytest
+    pytest-asyncio
     pytest-timeout
-    pytest-xdist
+    aiohttp
+    aiodns
 
 [testenv:lint]
 skipsdist = True

deltachat-rpc-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.126.1"
+version = "1.122.0"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"

deny.toml

@@ -11,6 +11,7 @@ ignore = [
 # when upgrading.
 # Please keep this list alphabetically sorted.
 skip = [
+     { name = "ahash", version = "0.7.6" },
      { name = "base16ct", version = "0.1.1" },
      { name = "base64", version = "<0.21" },
      { name = "bitflags", version = "1.3.2" },

draft/aeap-mvp.md

@@ -108,7 +108,7 @@ The most obvious alternative would be to create a new contact with the new addre
 #### Upsides:
 - With this approach, it's easier to switch to a model where the info about the transition is encoded in the PGP key. Since the key is gossiped, the information about the transition will spread virally.
 - (Also, less important: Slightly faster transition: If you send a message to e.g. "Delta Chat Dev", all members of the "sub-group" "delta android" will know of your transition.)
-- It's easier to implement (if too many problems turn up, we can still switch to another approach and didn't waste that much development time.)
+- It's easier to implement (if too many problems turn up, we can still switch to another approach and didn't wast that much development time.)
 
 [full messages](https://github.com/deltachat/deltachat-core-rust/pull/2896#discussion_r852002161)
   

node/lib/context.ts

@@ -36,7 +36,7 @@ export class Context extends EventEmitter {
     }
   }
 
-  /** Opens a standalone context (without an account manager)
+  /** Opens a stanalone context (without an account manager)
    * automatically starts the event handler */
   static open(cwd: string): Context {
     const dbFile = join(cwd, 'db.sqlite')

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.126.1"
+  "version": "1.122.0"
 }

python/mypy.ini

@@ -24,5 +24,3 @@ ignore_missing_imports = True
 [mypy-imap_tools.*]
 ignore_missing_imports = True
 
-[mypy-distutils.*]
-ignore_missing_imports = True

python/src/deltachat/account.py

@@ -195,7 +195,7 @@ class Account:
         assert res != ffi.NULL, f"config value not found for: {name!r}"
         return from_dc_charpointer(res)
 
-    def _preconfigure_keypair(self, addr: str, secret: str) -> None:
+    def _preconfigure_keypair(self, addr: str, public: str, secret: str) -> None:
         """See dc_preconfigure_keypair() in deltachat.h.
 
         In other words, you don't need this.
@@ -203,7 +203,7 @@ class Account:
         res = lib.dc_preconfigure_keypair(
             self._dc_context,
             as_dc_charpointer(addr),
-            ffi.NULL,
+            as_dc_charpointer(public),
             as_dc_charpointer(secret),
         )
         if res == 0:
@@ -617,18 +617,18 @@ class Account:
     # meta API for start/stop and event based processing
     #
 
-    def run_account(self, addr=None, password=None, account_plugins=None, show_ffi=False, displayname=None):
+    def run_account(self, addr=None, password=None, account_plugins=None, show_ffi=False):
+        from .events import FFIEventLogger
+
         """get the account running, configure it if necessary. add plugins if provided.
 
         :param addr: the email address of the account
         :param password: the password of the account
         :param account_plugins: a list of plugins to add
         :param show_ffi: show low level ffi events
-        :param displayname: the display name of the account
         """
-        from .events import FFIEventLogger
-
         if show_ffi:
+            self.set_config("displayname", "bot")
             log = FFIEventLogger(self)
             self.add_account_plugin(log)
 
@@ -644,8 +644,6 @@ class Account:
             configtracker = self.configure()
             configtracker.wait_finish()
 
-        if displayname:
-            self.set_config("displayname", displayname)
         # start IO threads and configure if necessary
         self.start_io()
 

python/src/deltachat/contact.py

@@ -75,12 +75,9 @@ class Contact:
         """Return True if the contact is verified."""
         return lib.dc_contact_is_verified(self._dc_contact) == 2
 
-    def get_verifier(self, contact) -> Optional["Contact"]:
+    def get_verifier(self, contact):
         """Return the address of the contact that verified the contact."""
-        verifier_id = lib.dc_contact_get_verifier_id(contact._dc_contact)
-        if verifier_id == 0:
-            return None
-        return Contact(self.account, verifier_id)
+        return from_dc_charpointer(lib.dc_contact_get_verifier_addr(contact._dc_contact))
 
     def get_profile_image(self) -> Optional[str]:
         """Get contact profile image.

python/src/deltachat/testplugin.py

@@ -478,9 +478,10 @@ class ACFactory:
         except IndexError:
             pass
         else:
+            fname_pub = self.data.read_path(f"key/{keyname}-public.asc")
             fname_sec = self.data.read_path(f"key/{keyname}-secret.asc")
-            if fname_sec:
-                account._preconfigure_keypair(addr, fname_sec)
+            if fname_pub and fname_sec:
+                account._preconfigure_keypair(addr, fname_pub, fname_sec)
                 return True
             print(f"WARN: could not use preconfigured keys for {addr!r}")
 

python/tests/test_0_complex_or_slow.py

@@ -1,7 +1,6 @@
 import sys
 
 import pytest
-import deltachat as dc
 
 
 class TestGroupStressTests:
@@ -150,8 +149,9 @@ def test_qr_verified_group_and_chatting(acfactory, lp):
     assert msg.is_encrypted()
 
     lp.sec("ac2: Check that ac2 verified ac1")
+    # If we verified the contact ourselves then verifier addr == contact addr
     ac2_ac1_contact = ac2.get_contacts()[0]
-    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact).id == dc.const.DC_CONTACT_ID_SELF
+    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact) == ac1_addr
 
     lp.sec("ac2: send message and let ac1 read it")
     chat2.send_text("world")
@@ -176,9 +176,9 @@ def test_qr_verified_group_and_chatting(acfactory, lp):
 
     lp.sec("ac2: Check that ac1 verified ac3 for ac2")
     ac2_ac1_contact = ac2.get_contacts()[0]
-    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact).id == dc.const.DC_CONTACT_ID_SELF
+    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact) == ac1_addr
     ac2_ac3_contact = ac2.get_contacts()[1]
-    assert ac2.get_self_contact().get_verifier(ac2_ac3_contact).addr == ac1_addr
+    assert ac2.get_self_contact().get_verifier(ac2_ac3_contact) == ac1_addr
 
     lp.sec("ac2: send message and let ac3 read it")
     chat2.send_text("hi")
@@ -539,6 +539,8 @@ def test_see_new_verified_member_after_going_online(acfactory, tmp_path, lp):
     assert msg_in.text == msg_out.text
     assert msg_in.get_sender_contact().addr == ac2_addr
 
+    ac1.set_config("bcc_self", "0")
+
 
 def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
     """Another test for the bug #3836:
@@ -587,67 +589,4 @@ def test_use_new_verified_group_after_going_online(acfactory, tmp_path, lp):
     assert msg_in.get_sender_contact().addr == ac2.get_config("addr")
     assert msg_in.text == msg_out.text
 
-
-def test_verified_group_vs_delete_server_after(acfactory, tmp_path, lp):
-    """Test for the issue #4346:
-    - User is added to a verified group.
-    - First device of the user downloads "member added" from the group.
-    - First device removes "member added" from the server.
-    - Some new messages are sent to the group.
-    - Second device comes online, receives these new messages. The result is a verified group with unverified members.
-    - First device re-gossips Autocrypt keys to the group.
-    - Now the seconds device has all members verified.
-    """
-    ac1, ac2 = acfactory.get_online_accounts(2)
-    ac2_offl = acfactory.new_online_configuring_account(cloned_from=ac2)
-    for ac in [ac2, ac2_offl]:
-        ac.set_config("bcc_self", "1")
-    ac2.set_config("delete_server_after", "1")
-    ac2.set_config("gossip_period", "0")  # Re-gossip in every message
-    acfactory.bring_accounts_online()
-    dir = tmp_path / "exportdir"
-    dir.mkdir()
-    ac2.export_self_keys(str(dir))
-    ac2_offl.import_self_keys(str(dir))
-    ac2_offl.stop_io()
-
-    lp.sec("ac1: create verified-group QR, ac2 scans and joins")
-    chat1 = ac1.create_group_chat("hello", verified=True)
-    assert chat1.is_protected()
-    qr = chat1.get_join_qr()
-    lp.sec("ac2: start QR-code based join-group protocol")
-    chat2 = ac2.qr_join_chat(qr)
-    ac1._evtracker.wait_securejoin_inviter_progress(1000)
-    # Wait for "Member Me (<addr>) added by <addr>." message.
-    msg_in = ac2._evtracker.wait_next_incoming_message()
-    assert msg_in.is_system_message()
-
-    lp.sec("ac2: waiting for 'member added' to be deleted on the server")
-    ac2._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
-
-    lp.sec("ac1: sending 'hi' to the group")
-    ac2.set_config("delete_server_after", "0")
-    chat1.send_text("hi")
-
-    lp.sec("ac2_offl: going online, checking the 'hi' message")
-    ac2_offl.start_io()
-    msg_in = ac2_offl._evtracker.wait_next_incoming_message()
-    assert not msg_in.is_system_message()
-    assert msg_in.text.startswith("[Sender of this message is not verified:")
-    ac2_offl_ac1_contact = msg_in.get_sender_contact()
-    assert ac2_offl_ac1_contact.addr == ac1.get_config("addr")
-    assert not ac2_offl_ac1_contact.is_verified()
-    chat2_offl = msg_in.chat
-    assert chat2_offl.is_protected()
-
-    lp.sec("ac2: sending message re-gossiping Autocrypt keys")
-    chat2.send_text("hi2")
-
-    lp.sec("ac2_offl: receiving message")
-    ev = ac2_offl._evtracker.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
-    msg_in = ac2_offl.get_message_by_id(ev.data2)
-    assert not msg_in.is_system_message()
-    assert msg_in.text == "hi2"
-    assert msg_in.chat == chat2_offl
-    assert msg_in.get_sender_contact().addr == ac2.get_config("addr")
-    assert ac2_offl_ac1_contact.is_verified()
+    ac2.set_config("bcc_self", "0")

python/tests/test_1_online.py

@@ -1698,10 +1698,12 @@ def test_qr_new_group_unblocked(acfactory, lp):
 
     ac1_new_chat = ac1.create_group_chat("Another group")
     ac1_new_chat.add_contact(ac2)
+    ac1_new_chat.send_text("Hello!")
+
     # Receive "Member added" message.
     ac2._evtracker.wait_next_incoming_message()
 
-    ac1_new_chat.send_text("Hello!")
+    # Receive "Hello!" message.
     ac2_msg = ac2._evtracker.wait_next_incoming_message()
     assert ac2_msg.text == "Hello!"
     assert ac2_msg.chat.is_contact_request()
@@ -1924,15 +1926,13 @@ def test_set_get_group_image(acfactory, data, lp):
     lp.sec("ac1: add ac2 to promoted group chat")
     chat.add_contact(ac2)  # sends one message
 
-    lp.sec("ac2: wait for receiving member added message from ac1")
-    msg1 = ac2._evtracker.wait_next_incoming_message()
-    assert msg1.is_system_message()  # Member added
-
     lp.sec("ac1: send a first message to ac2")
     chat.send_text("hi")  # sends another message
     assert chat.is_promoted()
 
     lp.sec("ac2: wait for receiving message from ac1")
+    msg1 = ac2._evtracker.wait_next_incoming_message()
+    assert msg1.is_system_message()  # Member added
     msg2 = ac2._evtracker.wait_next_incoming_message()
     assert msg2.text == "hi"
     assert msg1.chat.id == msg2.chat.id

python/tests/test_3_offline.py

@@ -67,9 +67,10 @@ class TestOfflineAccountBasic:
 
     def test_preconfigure_keypair(self, acfactory, data):
         ac = acfactory.get_unconfigured_account()
+        alice_public = data.read_path("key/alice-public.asc")
         alice_secret = data.read_path("key/alice-secret.asc")
-        assert alice_secret
-        ac._preconfigure_keypair("alice@example.org", alice_secret)
+        assert alice_public and alice_secret
+        ac._preconfigure_keypair("alice@example.org", alice_public, alice_secret)
 
     def test_getinfo(self, acfactory):
         ac1 = acfactory.get_unconfigured_account()

python/tests/test_4_lowlevel.py

@@ -1,4 +1,3 @@
-import json
 from queue import Queue
 
 import deltachat as dc
@@ -227,26 +226,10 @@ def test_jsonrpc_blocking_call(tmp_path):
         lib.dc_accounts_unref,
     )
     jsonrpc = ffi.gc(lib.dc_jsonrpc_init(accounts), lib.dc_jsonrpc_unref)
-    res = json.loads(
-        from_optional_dc_charpointer(
-            lib.dc_jsonrpc_blocking_call(
-                jsonrpc,
-                json.dumps(
-                    {"jsonrpc": "2.0", "method": "check_email_validity", "params": ["alice@example.org"], "id": "123"},
-                ).encode("utf-8"),
-            ),
-        ),
+    res = from_optional_dc_charpointer(
+        lib.dc_jsonrpc_blocking_call(jsonrpc, b"check_email_validity", b'["alice@example.org"]'),
     )
-    assert res == {"jsonrpc": "2.0", "id": "123", "result": True}
+    assert res == "true"
 
-    res = json.loads(
-        from_optional_dc_charpointer(
-            lib.dc_jsonrpc_blocking_call(
-                jsonrpc,
-                json.dumps(
-                    {"jsonrpc": "2.0", "method": "check_email_validity", "params": ["alice"], "id": "456"},
-                ).encode("utf-8"),
-            ),
-        ),
-    )
-    assert res == {"jsonrpc": "2.0", "id": "456", "result": False}
+    res = from_optional_dc_charpointer(lib.dc_jsonrpc_blocking_call(jsonrpc, b"check_email_validity", b'["alice"]'))
+    assert res == "false"

python/tox.ini

@@ -25,9 +25,6 @@ deps =
     pytest-xdist
     pdbpp
     requests
-# urllib3 2.0 does not work in manylinux2014 containers.
-# https://github.com/deltachat/deltachat-core-rust/issues/4788
-    urllib3<2
 
 [testenv:.pkg]
 passenv =

release-date.in

@@ -1 +1 @@
-2023-10-24
+2023-09-12

scripts/README.md

@@ -10,8 +10,6 @@ and an own build machine.
 
 - `deny.sh` runs `cargo deny` for all Rust code in the project.
 
-- `codespell.sh` spellchecks the source code using `codespell` tool.
-
 - `../.github/workflows` contains jobs run by GitHub Actions.
 
 - `remote_tests_python.sh` rsyncs to a build machine and runs
@@ -20,7 +18,7 @@ and an own build machine.
 - `remote_tests_rust.sh` rsyncs to the build machine and runs
   `run-rust-test.sh` remotely on the build machine. 
 
-- `make-python-testenv.sh` creates local python test development environment.
+- `make-python-testenv.sh` creates or updates local python test development environment.
   Reusing the same environment is faster than running `run-python-test.sh` which always
   recreates environment from scratch and runs additional lints.
 

scripts/make-python-testenv.sh

@@ -4,8 +4,8 @@
 # It rebuilds the core and bindings as needed.
 #
 # After running the script, you can either
-# run `pytest` directly with `venv/bin/pytest python/`
-# or activate the environment with `. venv/bin/activate`
+# run `pytest` directly with `env/bin/pytest python/`
+# or activate the environment with `. env/bin/activacte`
 # and run `pytest` from there.
 set -euo pipefail
 
@@ -13,5 +13,9 @@ export DCC_RS_TARGET=debug
 export DCC_RS_DEV="$PWD"
 cargo build -p deltachat_ffi --features jsonrpc
 
-tox -c python -e py --devenv venv
-venv/bin/pip install --upgrade pip
+if test -d env; then
+	env/bin/pip install -e python --force-reinstall
+else
+	tox -e py --devenv env
+	env/bin/pip install --upgrade pip
+fi

scripts/run_all.sh

@@ -31,7 +31,7 @@ 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,py312,pypy37,pypy38,pypy39,pypy310 --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"
 

scripts/wheel-rpc-server.py

@@ -1,197 +0,0 @@
-#!/usr/bin/env python3
-"""Build Python wheels for deltachat-rpc-server.
-Run scripts/zig-rpc-server.sh first."""
-from pathlib import Path
-from wheel.wheelfile import WheelFile
-import tomllib
-import tarfile
-from io import BytesIO
-
-
-def metadata_contents(version):
-    return f"""Metadata-Version: 2.1
-Name: deltachat-rpc-server
-Version: {version}
-Summary: Delta Chat JSON-RPC server
-"""
-
-
-def build_source_package(version):
-    filename = f"dist/deltachat-rpc-server-{version}.tar.gz"
-
-    with tarfile.open(filename, "w:gz") as pkg:
-
-        def pack(name, contents):
-            contents = contents.encode()
-            tar_info = tarfile.TarInfo(f"deltachat-rpc-server-{version}/{name}")
-            tar_info.mode = 0o644
-            tar_info.size = len(contents)
-            pkg.addfile(tar_info, BytesIO(contents))
-
-        pack("PKG-INFO", metadata_contents(version))
-        pack(
-            "pyproject.toml",
-            f"""[build-system]
-requires = ["setuptools==68.2.2", "pip"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "deltachat-rpc-server"
-version = "{version}"
-
-[project.scripts]
-deltachat-rpc-server = "deltachat_rpc_server:main"
-""",
-        )
-        pack(
-            "setup.py",
-            f"""
-import sys
-from setuptools import setup, find_packages
-from distutils.cmd import Command
-from setuptools.command.install import install
-from setuptools.command.build import build
-import subprocess
-import platform
-import tempfile
-from zipfile import ZipFile
-from pathlib import Path
-import shutil
-
-
-class BuildCommand(build):
-    def run(self):
-        tmpdir = tempfile.mkdtemp()
-        subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "pip",
-                "download",
-                "--no-input",
-                "--timeout",
-                "1000",
-                "--platform",
-                "musllinux_1_1_" + platform.machine(),
-                "--only-binary=:all:",
-                "deltachat-rpc-server=={version}",
-            ],
-            cwd=tmpdir,
-        )
-
-        wheel_path = next(Path(tmpdir).glob("*.whl"))
-        with ZipFile(wheel_path, "r") as wheel:
-            exe_path = wheel.extract("deltachat_rpc_server/deltachat-rpc-server", "src")
-            Path(exe_path).chmod(0o700)
-            wheel.extract("deltachat_rpc_server/__init__.py", "src")
-
-        shutil.rmtree(tmpdir)
-        return super().run()
-
-
-setup(
-    cmdclass={{"build": BuildCommand}},
-    package_data={{"deltachat_rpc_server": ["deltachat-rpc-server"]}},
-)
-""",
-        )
-        pack("src/deltachat_rpc_server/__init__.py", "")
-
-
-def build_wheel(version, binary, tag, windows=False):
-    filename = f"dist/deltachat_rpc_server-{version}-{tag}.whl"
-
-    with WheelFile(filename, "w") as wheel:
-        wheel.write("LICENSE", "deltachat_rpc_server/LICENSE")
-        wheel.write("deltachat-rpc-server/README.md", "deltachat_rpc_server/README.md")
-        if windows:
-            wheel.writestr(
-                "deltachat_rpc_server/__init__.py",
-                """import os, sys, subprocess
-def main():
-    argv = [os.path.join(os.path.dirname(__file__), "deltachat-rpc-server.exe"), *sys.argv[1:]]
-    sys.exit(subprocess.call(argv))
-""",
-            )
-        else:
-            wheel.writestr(
-                "deltachat_rpc_server/__init__.py",
-                """import os, sys
-def main():
-    argv = [os.path.join(os.path.dirname(__file__), "deltachat-rpc-server"), *sys.argv[1:]]
-    os.execv(argv[0], argv)
-""",
-            )
-
-        Path(binary).chmod(0o755)
-        wheel.write(
-            binary,
-            "deltachat_rpc_server/deltachat-rpc-server.exe"
-            if windows
-            else "deltachat_rpc_server/deltachat-rpc-server",
-        )
-        wheel.writestr(
-            f"deltachat_rpc_server-{version}.dist-info/METADATA",
-            metadata_contents(version),
-        )
-        wheel.writestr(
-            f"deltachat_rpc_server-{version}.dist-info/WHEEL",
-            "Wheel-Version: 1.0\nRoot-Is-Purelib: false\nTag: {tag}",
-        )
-        wheel.writestr(
-            f"deltachat_rpc_server-{version}.dist-info/entry_points.txt",
-            "[console_scripts]\ndeltachat-rpc-server = deltachat_rpc_server:main",
-        )
-
-
-def main():
-    with open("deltachat-rpc-server/Cargo.toml", "rb") as f:
-        cargo_toml = tomllib.load(f)
-        version = cargo_toml["package"]["version"]
-    Path("dist").mkdir(exist_ok=True)
-    build_source_package(version)
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-x86_64-linux",
-        "py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.musllinux_1_1_x86_64",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-armv7-linux",
-        "py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-aarch64-linux",
-        "py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-i686-linux",
-        "py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686",
-    )
-
-    # macOS versions for platform compatibility tags are taken from https://doc.rust-lang.org/rustc/platform-support.html
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-x86_64-macos",
-        "py3-none-macosx_10_7_x86_64",
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-aarch64-macos",
-        "py3-none-macosx_11_0_arm64",
-    )
-
-    build_wheel(
-        version, "dist/deltachat-rpc-server-win32.exe", "py3-none-win32", windows=True
-    )
-    build_wheel(
-        version,
-        "dist/deltachat-rpc-server-win64.exe",
-        "py3-none-win_amd64",
-        windows=True,
-    )
-
-
-main()

scripts/zig-cc

@@ -1,20 +1,10 @@
 #!/usr/bin/env python
-# /// pyproject
-# [run]
-# dependencies = [
-#   "ziglang==0.11.0"
-# ]
-# ///
-import os
 import subprocess
 import sys
+import os
 
 
 def flag_filter(flag: str) -> bool:
-    # Workaround for <https://github.com/sfackler/rust-openssl/issues/2043>.
-    if flag == "-latomic":
-        return False
-
     if flag == "-lc":
         return False
     if flag == "-Wl,-melf_i386":
@@ -34,23 +24,8 @@ def main():
     else:
         zig_cpu_args = []
 
-    # Disable atomics and use locks instead in OpenSSL.
-    # Zig toolchains do not provide atomics.
-    # This is a workaround for <https://github.com/deltachat/deltachat-core-rust/issues/4799>
-    args += ["-DBROKEN_CLANG_ATOMICS"]
-
     subprocess.run(
-        [
-            sys.executable,
-            "-m",
-            "ziglang",
-            "cc",
-            "-target",
-            zig_target,
-            *zig_cpu_args,
-            *args,
-        ],
-        check=True,
+        ["zig", "cc", "-target", zig_target, *zig_cpu_args, *args], check=True
     )
 
 

scripts/zig-musl-check.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+#
+# Run `cargo check` with musl libc.
+# This requires `zig` to compile vendored openssl.
+
+set -x
+set -e
+
+unset RUSTFLAGS
+
+# Pin Rust version to avoid uncontrolled changes in the compiler and linker flags.
+export RUSTUP_TOOLCHAIN=1.72.0
+
+ZIG_VERSION=0.11.0
+
+# Download Zig
+rm -fr "$ZIG_VERSION" "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
+wget "https://ziglang.org/builds/zig-linux-x86_64-$ZIG_VERSION.tar.xz"
+tar xf "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
+export PATH="$PWD/zig-linux-x86_64-$ZIG_VERSION:$PATH"
+
+rustup target add 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 check --release --target x86_64-unknown-linux-musl -p deltachat_ffi --features jsonrpc

scripts/zig-rpc-server.sh

@@ -10,6 +10,14 @@ unset RUSTFLAGS
 # Pin Rust version to avoid uncontrolled changes in the compiler and linker flags.
 export RUSTUP_TOOLCHAIN=1.72.0
 
+ZIG_VERSION=0.11.0
+
+# Download Zig
+rm -fr "$ZIG_VERSION" "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
+wget "https://ziglang.org/builds/zig-linux-x86_64-$ZIG_VERSION.tar.xz"
+tar xf "zig-linux-x86_64-$ZIG_VERSION.tar.xz"
+export PATH="$PWD/zig-linux-x86_64-$ZIG_VERSION:$PATH"
+
 rustup target add i686-unknown-linux-musl
 CC="$PWD/scripts/zig-cc" \
 TARGET_CC="$PWD/scripts/zig-cc" \
@@ -42,9 +50,3 @@ 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
-
-mkdir -p dist
-cp target/x86_64-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-x86_64-linux
-cp target/i686-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-i686-linux
-cp target/aarch64-unknown-linux-musl/release/deltachat-rpc-server dist/deltachat-rpc-server-aarch64-linux
-cp target/armv7-unknown-linux-musleabihf/release/deltachat-rpc-server dist/deltachat-rpc-server-armv7-linux

spec.md

@@ -43,7 +43,7 @@ the `Subject` header SHOULD be `Message from <sender name>`.
 Replies to messages MAY follow the typical `Re:`-format.
 
 The body MAY contain text which MUST have the content type `text/plain`
-or `multipart/alternative` containing `text/plain`.
+or `mulipart/alternative` containing `text/plain`.
 
 The text MAY be divided into a user-text-part and a footer-part using the
 line `-- ` (minus, minus, space, lineend).

src/chat.rs

@@ -918,10 +918,9 @@ impl ChatId {
             .sql
             .query_map(
                 "SELECT chat_id, count(*) AS n
-                 FROM chats_contacts
-                 WHERE contact_id > ? AND chat_id > ?
+                 FROM chats_contacts where contact_id > 9
                  GROUP BY chat_id",
-                (ContactId::LAST_SPECIAL, DC_CHAT_ID_LAST_SPECIAL),
+                (),
                 |row| {
                     let chat_id: ChatId = row.get(0)?;
                     let size: f64 = row.get(1)?;
@@ -2337,7 +2336,7 @@ 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 against RTLO attacks
+    // protect all system messages againts RTLO attacks
     if msg.is_system_message() {
         msg.text = strip_rtlo_characters(&msg.text);
     }
@@ -2898,9 +2897,6 @@ pub enum Direction {
 }
 
 /// Searches next/previous message based on the given message and list of types.
-///
-/// Deprecated since 2023-10-03.
-#[deprecated(note = "use `get_chat_media` instead")]
 pub async fn get_next_media(
     context: &Context,
     curr_msg_id: MsgId,
@@ -3532,8 +3528,6 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
         msg.param.remove(Param::ForcePlaintext);
         msg.param.remove(Param::Cmd);
         msg.param.remove(Param::OverrideSenderDisplayname);
-        msg.param.remove(Param::WebxdcDocument);
-        msg.param.remove(Param::WebxdcDocumentTimestamp);
         msg.param.remove(Param::WebxdcSummary);
         msg.param.remove(Param::WebxdcSummaryTimestamp);
         msg.in_reply_to = None;
@@ -6094,40 +6088,22 @@ mod tests {
             get_chat_contacts(&alice, chat_bob.id).await?.pop().unwrap(),
         )
         .await?;
-        set_chat_name(&alice, broadcast_id, "Broadcast list").await?;
-        {
-            let chat = Chat::load_from_db(&alice, broadcast_id).await?;
-            assert_eq!(chat.typ, Chattype::Broadcast);
-            assert_eq!(chat.name, "Broadcast list");
-            assert!(!chat.is_self_talk());
+        let chat = Chat::load_from_db(&alice, broadcast_id).await?;
+        assert_eq!(chat.typ, Chattype::Broadcast);
+        assert_eq!(chat.name, stock_str::broadcast_list(&alice).await);
+        assert!(!chat.is_self_talk());
 
-            send_text_msg(&alice, broadcast_id, "ola!".to_string()).await?;
-            let msg = alice.get_last_msg().await;
-            assert_eq!(msg.chat_id, chat.id);
-        }
+        send_text_msg(&alice, broadcast_id, "ola!".to_string()).await?;
+        let msg = alice.get_last_msg().await;
+        assert_eq!(msg.chat_id, chat.id);
 
-        {
-            let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
-            assert_eq!(msg.get_text(), "ola!");
-            assert_eq!(msg.subject, "Broadcast list");
-            assert!(!msg.get_showpadlock()); // avoid leaking recipients in encryption data
-            let chat = Chat::load_from_db(&bob, msg.chat_id).await?;
-            assert_eq!(chat.typ, Chattype::Mailinglist);
-            assert_ne!(chat.id, chat_bob.id);
-            assert_eq!(chat.name, "Broadcast list");
-            assert!(!chat.is_self_talk());
-        }
-
-        {
-            // Alice changes the name:
-            set_chat_name(&alice, broadcast_id, "My great broadcast").await?;
-            let sent = alice.send_text(broadcast_id, "I changed the title!").await;
-
-            let msg = bob.recv_msg(&sent).await;
-            assert_eq!(msg.subject, "Re: My great broadcast");
-            let bob_chat = Chat::load_from_db(&bob, msg.chat_id).await?;
-            assert_eq!(bob_chat.name, "My great broadcast");
-        }
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
+        assert_eq!(msg.get_text(), "ola!");
+        assert!(!msg.get_showpadlock()); // avoid leaking recipients in encryption data
+        let chat = Chat::load_from_db(&bob, msg.chat_id).await?;
+        assert_eq!(chat.typ, Chattype::Single);
+        assert_eq!(chat.id, chat_bob.id);
+        assert!(!chat.is_self_talk());
 
         Ok(())
     }

src/chatlist.rs

@@ -1,7 +1,6 @@
 //! # Chat list module.
 
 use anyhow::{ensure, Context as _, Result};
-use once_cell::sync::Lazy;
 
 use crate::chat::{update_special_chat_names, Chat, ChatId, ChatVisibility};
 use crate::constants::{
@@ -16,10 +15,6 @@ use crate::stock_str;
 use crate::summary::Summary;
 use crate::tools::IsNoneOrEmpty;
 
-/// Regex to find out if a query should filter by unread messages.
-pub static IS_UNREAD_FILTER: Lazy<regex::Regex> =
-    Lazy::new(|| regex::Regex::new(r"\bis:unread\b").unwrap());
-
 /// An object representing a single chatlist in memory.
 ///
 /// Chatlist objects contain chat IDs and, if possible, message IDs belonging to them.
@@ -83,8 +78,7 @@ impl Chatlist {
     /// - if the flag DC_GCL_ADD_ALLDONE_HINT is set, DC_CHAT_ID_ALLDONE_HINT
     ///   is added as needed.
     /// `query`: An optional query for filtering the list. Only chats matching this query
-    ///     are returned. When `is:unread` is contained in the query, the chatlist is
-    ///     filtered such that only chats with unread messages show up.
+    ///     are returned.
     /// `query_contact_id`: An optional contact ID for filtering the list. Only chats including this contact ID
     ///     are returned.
     pub async fn try_load(
@@ -178,10 +172,8 @@ impl Chatlist {
                 )
                 .await?
         } else if let Some(query) = query {
-            let mut query = query.trim().to_string();
-            ensure!(!query.is_empty(), "query mustn't be empty");
-            let only_unread = IS_UNREAD_FILTER.find(&query).is_some();
-            query = IS_UNREAD_FILTER.replace(&query, "").trim().to_string();
+            let query = query.trim().to_string();
+            ensure!(!query.is_empty(), "missing query");
 
             // allow searching over special names that may change at any time
             // when the ui calls set_stock_translation()
@@ -206,10 +198,9 @@ impl Chatlist {
                  WHERE c.id>9 AND c.id!=?2
                    AND c.blocked!=1
                    AND c.name LIKE ?3
-                   AND (NOT ?4 OR EXISTS (SELECT 1 FROM msgs m WHERE m.chat_id = c.id AND m.state == ?5 AND hidden=0))
                  GROUP BY c.id
                  ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                    (MessageState::OutDraft, skip_id, str_like_cmd, only_unread, MessageState::InFresh),
+                    (MessageState::OutDraft, skip_id, str_like_cmd),
                     process_row,
                     process_rows,
                 )
@@ -471,8 +462,7 @@ pub async fn get_last_message_for_chat(
 mod tests {
     use super::*;
     use crate::chat::{
-        add_contact_to_chat, create_group_chat, get_chat_contacts, remove_contact_from_chat,
-        send_text_msg, ProtectionStatus,
+        create_group_chat, get_chat_contacts, remove_contact_from_chat, ProtectionStatus,
     };
     use crate::message::Viewtype;
     use crate::receive_imf::receive_imf;
@@ -481,7 +471,7 @@ mod tests {
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_try_load() {
-        let t = TestContext::new_bob().await;
+        let t = TestContext::new().await;
         let chat_id1 = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat")
             .await
             .unwrap();
@@ -520,31 +510,6 @@ mod tests {
         let chats = Chatlist::try_load(&t, 0, Some("b"), None).await.unwrap();
         assert_eq!(chats.len(), 1);
 
-        // receive a message from alice
-        let alice = TestContext::new_alice().await;
-        let alice_chat_id = create_group_chat(&alice, ProtectionStatus::Unprotected, "alice chat")
-            .await
-            .unwrap();
-        add_contact_to_chat(
-            &alice,
-            alice_chat_id,
-            Contact::create(&alice, "bob", "bob@example.net")
-                .await
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-        send_text_msg(&alice, alice_chat_id, "hi".into())
-            .await
-            .unwrap();
-        let sent_msg = alice.pop_sent_msg().await;
-
-        t.recv_msg(&sent_msg).await;
-        let chats = Chatlist::try_load(&t, 0, Some("is:unread"), None)
-            .await
-            .unwrap();
-        assert!(chats.len() == 1);
-
         let chats = Chatlist::try_load(&t, DC_GCL_ARCHIVED_ONLY, None, None)
             .await
             .unwrap();

src/config.rs

@@ -286,12 +286,6 @@ pub enum Config {
     #[strum(props(default = "60"))]
     ScanAllFoldersDebounceSecs,
 
-    /// Whether to avoid using IMAP IDLE even if the server supports it.
-    ///
-    /// This is a developer option for testing "fake idle".
-    #[strum(props(default = "0"))]
-    DisableIdle,
-
     /// Defines the max. size (in bytes) of messages downloaded automatically.
     /// 0 = no limit.
     #[strum(props(default = "0"))]
@@ -318,13 +312,6 @@ pub enum Config {
 
     /// Last message processed by the bot.
     LastMsgId,
-
-    /// How often to gossip Autocrypt keys in chats with multiple recipients, in seconds. 2 days by
-    /// default.
-    ///
-    /// This is not supposed to be changed by UIs and only used for testing.
-    #[strum(props(default = "172800"))]
-    GossipPeriod,
 }
 
 impl Context {
@@ -478,28 +465,6 @@ impl Context {
                     .set_raw_config(key.as_ref(), value.as_deref())
                     .await?;
             }
-            Config::Socks5Enabled
-            | Config::BccSelf
-            | Config::E2eeEnabled
-            | Config::MdnsEnabled
-            | Config::SentboxWatch
-            | Config::MvboxMove
-            | Config::OnlyFetchMvbox
-            | Config::FetchExistingMsgs
-            | Config::DeleteToTrash
-            | Config::SaveMimeHeaders
-            | Config::Configured
-            | Config::Bot
-            | Config::NotifyAboutWrongPw
-            | Config::SendSyncMsgs
-            | Config::SignUnencrypted
-            | Config::DisableIdle => {
-                ensure!(
-                    matches!(value, None | Some("0") | Some("1")),
-                    "Boolean value must be either 0 or 1"
-                );
-                self.sql.set_raw_config(key.as_ref(), value).await?;
-            }
             _ => {
                 self.sql.set_raw_config(key.as_ref(), value).await?;
             }
@@ -649,18 +614,6 @@ mod tests {
         );
     }
 
-    /// Tests that "bot" config can only be set to "0" or "1".
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_set_config_bot() {
-        let t = TestContext::new().await;
-
-        assert!(t.set_config(Config::Bot, None).await.is_ok());
-        assert!(t.set_config(Config::Bot, Some("0")).await.is_ok());
-        assert!(t.set_config(Config::Bot, Some("1")).await.is_ok());
-        assert!(t.set_config(Config::Bot, Some("2")).await.is_err());
-        assert!(t.set_config(Config::Bot, Some("Foobar")).await.is_err());
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_media_quality_config_option() {
         let t = TestContext::new().await;

src/configure.rs

@@ -26,6 +26,7 @@ use crate::config::Config;
 use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::imap::Imap;
+use crate::job;
 use crate::log::LogExt;
 use crate::login_param::{CertificateChecks, LoginParam, ServerLoginParam};
 use crate::message::{Message, Viewtype};
@@ -465,7 +466,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
         if configured_addr != param.addr {
             // Switched account, all server UIDs we know are invalid
             info!(ctx, "Scheduling resync because the address has changed.");
-            ctx.schedule_resync().await?;
+            job::schedule_resync(ctx).await?;
         }
     }
 

src/contact.rs

@@ -109,7 +109,7 @@ impl ContactId {
 
     /// ID of the contact for device messages.
     pub const DEVICE: ContactId = ContactId::new(5);
-    pub(crate) const LAST_SPECIAL: ContactId = ContactId::new(9);
+    const LAST_SPECIAL: ContactId = ContactId::new(9);
 
     /// Address to go with [`ContactId::DEVICE`].
     ///
@@ -812,11 +812,7 @@ impl Contact {
         let mut ret = Vec::new();
         let flag_verified_only = (listflags & DC_GCL_VERIFIED_ONLY) != 0;
         let flag_add_self = (listflags & DC_GCL_ADD_SELF) != 0;
-        let minimal_origin = if context.get_config_bool(Config::Bot).await? {
-            Origin::Unknown
-        } else {
-            Origin::IncomingReplyTo
-        };
+
         if flag_verified_only || query.is_some() {
             let s3str_like_cmd = format!("%{}%", query.unwrap_or(""));
             context
@@ -836,7 +832,7 @@ impl Contact {
                     ),
                     rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
                         ContactId::LAST_SPECIAL,
-                        minimal_origin,
+                        Origin::IncomingReplyTo,
                         s3str_like_cmd,
                         s3str_like_cmd,
                         if flag_verified_only { 0i32 } else { 1i32 }
@@ -886,10 +882,10 @@ impl Contact {
                  ORDER BY last_seen DESC, id DESC;",
                         sql::repeat_vars(self_addrs.len())
                     ),
-                    rusqlite::params_from_iter(
-                        params_iter(&self_addrs)
-                            .chain(params_slice![ContactId::LAST_SPECIAL, minimal_origin]),
-                    ),
+                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
+                        ContactId::LAST_SPECIAL,
+                        Origin::IncomingReplyTo
+                    ])),
                     |row| row.get::<_, ContactId>(0),
                     |ids| {
                         for id in ids {
@@ -1256,22 +1252,11 @@ impl Contact {
 
     /// Returns the ContactId that verified the contact.
     pub async fn get_verifier_id(&self, context: &Context) -> Result<Option<ContactId>> {
-        let Some(verifier_addr) = self.get_verifier_addr(context).await? else {
-            return Ok(None);
-        };
-
-        if verifier_addr == self.addr {
-            // Contact is directly verified via QR code.
-            return Ok(Some(ContactId::SELF));
-        }
-
-        match Contact::lookup_id_by_addr(context, &verifier_addr, Origin::Unknown).await? {
-            Some(contact_id) => Ok(Some(contact_id)),
-            None => {
-                let addr = &self.addr;
-                warn!(context, "Could not lookup contact with address {verifier_addr} which introduced {addr}.");
-                Ok(None)
-            }
+        let verifier_addr = self.get_verifier_addr(context).await?;
+        if let Some(addr) = verifier_addr {
+            Ok(Contact::lookup_id_by_addr(context, &addr, Origin::AddressBook).await?)
+        } else {
+            Ok(None)
         }
     }
 

src/context.rs

@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, HashMap};
 use std::ffi::OsString;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
@@ -23,7 +23,7 @@ use crate::key::{DcKey, SignedPublicKey};
 use crate::login_param::LoginParam;
 use crate::message::{self, MessageState, MsgId};
 use crate::quota::QuotaInfo;
-use crate::scheduler::{InterruptInfo, SchedulerState};
+use crate::scheduler::SchedulerState;
 use crate::sql::Sql;
 use crate::stock_str::StockStrings;
 use crate::timesmearing::SmearedTimestamp;
@@ -38,7 +38,7 @@ use crate::tools::{duration_to_str, time};
 ///
 /// # Examples
 ///
-/// Creating a new unencrypted database:
+/// Creating a new unecrypted database:
 ///
 /// ```
 /// # let rt = tokio::runtime::Runtime::new().unwrap();
@@ -211,6 +211,9 @@ pub struct InnerContext {
     /// Set to `None` if quota was never tried to load.
     pub(crate) quota: RwLock<Option<QuotaInfo>>,
 
+    /// Set to true if quota update is requested.
+    pub(crate) quota_update_request: AtomicBool,
+
     /// IMAP UID resync request.
     pub(crate) resync_request: AtomicBool,
 
@@ -379,8 +382,9 @@ impl Context {
             translated_stockstrings: stockstrings,
             events,
             scheduler: SchedulerState::new(),
-            ratelimit: RwLock::new(Ratelimit::new(Duration::new(60, 0), 6.0)), // Allow at least 1 message every 10 seconds + a burst of 6.
+            ratelimit: RwLock::new(Ratelimit::new(Duration::new(60, 0), 6.0)), // Allow to send 6 messages immediately, no more than once every 10 seconds.
             quota: RwLock::new(None),
+            quota_update_request: AtomicBool::new(false),
             resync_request: AtomicBool::new(false),
             new_msgs_notify,
             server_id: RwLock::new(None),
@@ -422,16 +426,6 @@ impl Context {
         self.scheduler.maybe_network().await;
     }
 
-    pub(crate) async fn schedule_resync(&self) -> Result<()> {
-        self.resync_request.store(true, Ordering::Relaxed);
-        self.scheduler
-            .interrupt_inbox(InterruptInfo {
-                probe_network: false,
-            })
-            .await;
-        Ok(())
-    }
-
     /// Returns a reference to the underlying SQL instance.
     ///
     /// Warning: this is only here for testing, not part of the public API.
@@ -585,7 +579,6 @@ impl Context {
         let mdns_enabled = self.get_config_int(Config::MdnsEnabled).await?;
         let bcc_self = self.get_config_int(Config::BccSelf).await?;
         let send_sync_msgs = self.get_config_int(Config::SendSyncMsgs).await?;
-        let disable_idle = self.get_config_bool(Config::DisableIdle).await?;
 
         let prv_key_cnt = self.sql.count("SELECT COUNT(*) FROM keypairs;", ()).await?;
 
@@ -698,7 +691,6 @@ impl Context {
         );
         res.insert("bcc_self", bcc_self.to_string());
         res.insert("send_sync_msgs", send_sync_msgs.to_string());
-        res.insert("disable_idle", disable_idle.to_string());
         res.insert("private_key_count", prv_key_cnt.to_string());
         res.insert("public_key_count", pub_key_cnt.to_string());
         res.insert("fingerprint", fingerprint_str);
@@ -760,6 +752,7 @@ impl Context {
                 .await?
                 .to_string(),
         );
+
         res.insert(
             "debug_logging",
             self.get_config_int(Config::DebugLogging).await?.to_string(),
@@ -768,10 +761,6 @@ impl Context {
             "last_msg_id",
             self.get_config_int(Config::LastMsgId).await?.to_string(),
         );
-        res.insert(
-            "gossip_period",
-            self.get_config_int(Config::GossipPeriod).await?.to_string(),
-        );
 
         let elapsed = self.creation_time.elapsed();
         res.insert("uptime", duration_to_str(elapsed.unwrap_or_default()));
@@ -825,22 +814,7 @@ impl Context {
     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 => {
-                // If `last_msg_id` is not set yet,
-                // subtract 1 from the last id,
-                // so a single message is returned and can
-                // be marked as seen.
-                self.sql
-                    .query_row(
-                        "SELECT IFNULL((SELECT MAX(id) - 1 FROM msgs), 0)",
-                        (),
-                        |row| {
-                            let msg_id: MsgId = row.get(0)?;
-                            Ok(msg_id)
-                        },
-                    )
-                    .await?
-            }
+            None => MsgId::new_unset(),
         };
 
         let list = self

src/download.rs

@@ -10,11 +10,11 @@ use serde::{Deserialize, Serialize};
 use crate::config::Config;
 use crate::context::Context;
 use crate::imap::{Imap, ImapActionResult};
+use crate::job::{self, Action, Job, Status};
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, Part};
-use crate::scheduler::InterruptInfo;
 use crate::tools::time;
-use crate::{stock_str, EventType};
+use crate::{job_try, stock_str, EventType};
 
 /// Download limits should not be used below `MIN_DOWNLOAD_LIMIT`.
 ///
@@ -23,7 +23,7 @@ use crate::{stock_str, EventType};
 /// eg. to assign them to the correct chat.
 /// As these messages are typically small,
 /// they're caught by `MIN_DOWNLOAD_LIMIT`.
-pub(crate) const MIN_DOWNLOAD_LIMIT: u32 = 32768;
+const MIN_DOWNLOAD_LIMIT: u32 = 32768;
 
 /// If a message is downloaded only partially
 /// and `delete_server_after` is set to small timeouts (eg. "at once"),
@@ -90,14 +90,7 @@ impl MsgId {
             DownloadState::Available | DownloadState::Failure => {
                 self.update_download_state(context, DownloadState::InProgress)
                     .await?;
-                context
-                    .sql
-                    .execute("INSERT INTO download (msg_id) VALUES (?)", (self,))
-                    .await?;
-                context
-                    .scheduler
-                    .interrupt_inbox(InterruptInfo::new(false))
-                    .await;
+                job::add(context, Job::new(Action::DownloadMsg, self.to_u32())).await?;
             }
         }
         Ok(())
@@ -131,49 +124,59 @@ impl Message {
     }
 }
 
-/// Actually download a message partially downloaded before.
-///
-/// Most messages are downloaded automatically on fetch instead.
-pub(crate) async fn download_msg(context: &Context, msg_id: MsgId, imap: &mut Imap) -> Result<()> {
-    imap.prepare(context).await?;
+impl Job {
+    /// Actually download a message.
+    /// Called in response to `Action::DownloadMsg`.
+    pub(crate) async fn download_msg(&self, context: &Context, imap: &mut Imap) -> Status {
+        if let Err(err) = imap.prepare(context).await {
+            warn!(context, "download: could not connect: {:#}", err);
+            return Status::RetryNow;
+        }
 
-    let msg = Message::load_from_db(context, msg_id).await?;
-    let row = context
-        .sql
-        .query_row_optional(
-            "SELECT uid, folder FROM imap WHERE rfc724_mid=? AND target!=''",
-            (&msg.rfc724_mid,),
-            |row| {
-                let server_uid: u32 = row.get(0)?;
-                let server_folder: String = row.get(1)?;
-                Ok((server_uid, server_folder))
-            },
-        )
-        .await?;
+        let msg = job_try!(Message::load_from_db(context, MsgId::new(self.foreign_id)).await);
+        let row = job_try!(
+            context
+                .sql
+                .query_row_optional(
+                    "SELECT uid, folder FROM imap WHERE rfc724_mid=? AND target=folder",
+                    (&msg.rfc724_mid,),
+                    |row| {
+                        let server_uid: u32 = row.get(0)?;
+                        let server_folder: String = row.get(1)?;
+                        Ok((server_uid, server_folder))
+                    }
+                )
+                .await
+        );
 
-    if let Some((server_uid, server_folder)) = row {
-        match imap
-            .fetch_single_msg(context, &server_folder, server_uid, msg.rfc724_mid.clone())
-            .await
-        {
-            ImapActionResult::RetryLater | ImapActionResult::Failed => {
+        if let Some((server_uid, server_folder)) = row {
+            match imap
+                .fetch_single_msg(context, &server_folder, server_uid, msg.rfc724_mid.clone())
+                .await
+            {
+                ImapActionResult::RetryLater | ImapActionResult::Failed => {
+                    job_try!(
+                        msg.id
+                            .update_download_state(context, DownloadState::Failure)
+                            .await
+                    );
+                    Status::Finished(Err(anyhow!("Call download_full() again to try over.")))
+                }
+                ImapActionResult::Success => {
+                    // update_download_state() not needed as receive_imf() already
+                    // set the state and emitted the event.
+                    Status::Finished(Ok(()))
+                }
+            }
+        } else {
+            // No IMAP record found, we don't know the UID and folder.
+            job_try!(
                 msg.id
                     .update_download_state(context, DownloadState::Failure)
-                    .await?;
-                Err(anyhow!("Call download_full() again to try over."))
-            }
-            ImapActionResult::Success => {
-                // update_download_state() not needed as receive_imf() already
-                // set the state and emitted the event.
-                Ok(())
-            }
+                    .await
+            );
+            Status::Finished(Err(anyhow!("Call download_full() again to try over.")))
         }
-    } else {
-        // No IMAP record found, we don't know the UID and folder.
-        msg.id
-            .update_download_state(context, DownloadState::Failure)
-            .await?;
-        Err(anyhow!("Call download_full() again to try over."))
     }
 }
 

src/imap.rs

@@ -26,6 +26,7 @@ use crate::contact::{normalize_name, Contact, ContactAddress, ContactId, Modifie
 use crate::context::Context;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
+use crate::job;
 use crate::login_param::{CertificateChecks, LoginParam, ServerLoginParam};
 use crate::message::{self, Message, MessageState, MessengerMessage, MsgId, Viewtype};
 use crate::mimeparser;
@@ -81,6 +82,7 @@ const RFC724MID_UID: &str = "(UID BODY.PEEK[HEADER.FIELDS (\
                              MESSAGE-ID \
                              X-MICROSOFT-ORIGINAL-MESSAGE-ID\
                              )])";
+const JUST_UID: &str = "(UID)";
 const BODY_FULL: &str = "(FLAGS BODY.PEEK[])";
 const BODY_PARTIAL: &str = "(FLAGS RFC822.SIZE BODY.PEEK[HEADER])";
 
@@ -389,7 +391,6 @@ impl Imap {
                     "IMAP-LOGIN as {}",
                     self.config.lp.user
                 )));
-                self.connectivity.set_connected(context).await;
                 info!(context, "Successfully logged into IMAP server");
                 Ok(())
             }
@@ -613,7 +614,7 @@ impl Imap {
                         "The server illegally decreased the uid_next of folder {folder:?} from {old_uid_next} to {uid_next} without changing validity ({new_uid_validity}), resyncing UIDs...",
                     );
                     set_uid_next(context, folder, uid_next).await?;
-                    context.schedule_resync().await?;
+                    job::schedule_resync(context).await?;
                 }
                 uid_next != old_uid_next // If uid_next changed, there are new emails
             } else {
@@ -625,6 +626,18 @@ impl Imap {
         // UIDVALIDITY is modified, reset highest seen MODSEQ.
         set_modseq(context, folder, 0).await?;
 
+        if mailbox.exists == 0 {
+            info!(context, "Folder {folder:?} is empty.");
+
+            // set uid_next=1 for empty folders.
+            // If we do not do this here, we'll miss the first message
+            // as we will get in here again and fetch from uid_next then.
+            // Also, the "fall back to fetching" below would need a non-zero mailbox.exists to work.
+            set_uid_next(context, folder, 1).await?;
+            set_uidvalidity(context, folder, new_uid_validity).await?;
+            return Ok(false);
+        }
+
         // ==============  uid_validity has changed or is being set the first time.  ==============
 
         let new_uid_next = match mailbox.uid_next {
@@ -632,35 +645,25 @@ impl Imap {
             None => {
                 warn!(
                     context,
-                    "SELECT response for IMAP folder {folder:?} has no UIDNEXT, fall back to STATUS command."
+                    "IMAP folder {folder:?} has no uid_next, fall back to fetching."
                 );
-
-                // RFC 3501 says STATUS command SHOULD NOT be used
-                // on the currently selected mailbox because the same
-                // information can be obtained by other means,
-                // such as reading SELECT response.
-                //
-                // However, it also says that UIDNEXT is REQUIRED
-                // in the SELECT response and if we are here,
-                // it is actually not returned.
-                //
-                // In particular, Winmail Pro Mail Server 5.1.0616
-                // never returns UIDNEXT in SELECT response,
-                // but responds to "SELECT INBOX (UIDNEXT)" command.
-                let status = session
+                // note that we use fetch by sequence number
+                // and thus we only need to get exactly the
+                // last-index message.
+                let set = format!("{}", mailbox.exists);
+                let mut list = session
                     .inner
-                    .status(folder, "(UIDNEXT)")
+                    .fetch(set, JUST_UID)
                     .await
-                    .context("STATUS (UIDNEXT) error for {folder:?}")?;
+                    .context("Error fetching UID")?;
 
-                if let Some(uid_next) = status.uid_next {
-                    uid_next
-                } else {
-                    warn!(context, "STATUS {folder} (UIDNEXT) did not return UIDNEXT");
-
-                    // Set UIDNEXT to 1 as a last resort fallback.
-                    1
+                let mut new_last_seen_uid = None;
+                while let Some(fetch) = list.try_next().await? {
+                    if fetch.message == mailbox.exists && fetch.uid.is_some() {
+                        new_last_seen_uid = fetch.uid;
+                    }
                 }
+                new_last_seen_uid.context("select: failed to fetch")? + 1
             }
         };
 
@@ -677,7 +680,7 @@ impl Imap {
             .await?;
 
         if old_uid_validity != 0 || old_uid_next != 0 {
-            context.schedule_resync().await?;
+            job::schedule_resync(context).await?;
         }
         info!(
             context,

src/imap/client.rs

@@ -15,7 +15,6 @@ use crate::net::connect_tcp;
 use crate::net::session::SessionStream;
 use crate::net::tls::wrap_tls;
 use crate::socks::Socks5Config;
-use fast_socks5::client::Socks5Stream;
 
 /// IMAP write and read timeout.
 pub(crate) const IMAP_TIMEOUT: Duration = Duration::from_secs(30);
@@ -65,12 +64,6 @@ async fn determine_capabilities(
 }
 
 impl Client {
-    fn new(stream: Box<dyn SessionStream>) -> Self {
-        Self {
-            inner: ImapClient::new(stream),
-        }
-    }
-
     pub(crate) async fn login(self, username: &str, password: &str) -> Result<Session> {
         let Client { inner, .. } = self;
         let mut session = inner
@@ -105,24 +98,27 @@ impl Client {
         let tls_stream = wrap_tls(strict_tls, hostname, tcp_stream).await?;
         let buffered_stream = BufWriter::new(tls_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = Client::new(session_stream);
+        let mut client = ImapClient::new(session_stream);
+
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-        Ok(client)
+
+        Ok(Client { inner: client })
     }
 
     pub async fn connect_insecure(context: &Context, hostname: &str, port: u16) -> Result<Self> {
         let tcp_stream = connect_tcp(context, hostname, port, IMAP_TIMEOUT, false).await?;
         let buffered_stream = BufWriter::new(tcp_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = Client::new(session_stream);
+        let mut client = ImapClient::new(session_stream);
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-        Ok(client)
+
+        Ok(Client { inner: client })
     }
 
     pub async fn connect_starttls(
@@ -134,8 +130,7 @@ impl Client {
         let tcp_stream = connect_tcp(context, hostname, port, IMAP_TIMEOUT, strict_tls).await?;
 
         // Run STARTTLS command and convert the client back into a stream.
-        let buffered_tcp_stream = BufWriter::new(tcp_stream);
-        let mut client = ImapClient::new(buffered_tcp_stream);
+        let mut client = ImapClient::new(tcp_stream);
         let _greeting = client
             .read_response()
             .await
@@ -144,8 +139,7 @@ impl Client {
             .run_command_and_check_ok("STARTTLS", None)
             .await
             .context("STARTTLS command failed")?;
-        let buffered_tcp_stream = client.into_inner();
-        let tcp_stream = buffered_tcp_stream.into_inner();
+        let tcp_stream = client.into_inner();
 
         let tls_stream = wrap_tls(strict_tls, hostname, tcp_stream)
             .await
@@ -153,8 +147,9 @@ impl Client {
 
         let buffered_stream = BufWriter::new(tls_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let client = Client::new(session_stream);
-        Ok(client)
+        let client = ImapClient::new(session_stream);
+
+        Ok(Client { inner: client })
     }
 
     pub async fn connect_secure_socks5(
@@ -170,12 +165,13 @@ impl Client {
         let tls_stream = wrap_tls(strict_tls, domain, socks5_stream).await?;
         let buffered_stream = BufWriter::new(tls_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = Client::new(session_stream);
+        let mut client = ImapClient::new(session_stream);
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-        Ok(client)
+
+        Ok(Client { inner: client })
     }
 
     pub async fn connect_insecure_socks5(
@@ -189,12 +185,13 @@ impl Client {
             .await?;
         let buffered_stream = BufWriter::new(socks5_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = Client::new(session_stream);
+        let mut client = ImapClient::new(session_stream);
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-        Ok(client)
+
+        Ok(Client { inner: client })
     }
 
     pub async fn connect_starttls_socks5(
@@ -209,8 +206,7 @@ impl Client {
             .await?;
 
         // Run STARTTLS command and convert the client back into a stream.
-        let buffered_socks5_stream = BufWriter::new(socks5_stream);
-        let mut client = ImapClient::new(buffered_socks5_stream);
+        let mut client = ImapClient::new(socks5_stream);
         let _greeting = client
             .read_response()
             .await
@@ -219,15 +215,15 @@ impl Client {
             .run_command_and_check_ok("STARTTLS", None)
             .await
             .context("STARTTLS command failed")?;
-        let buffered_socks5_stream = client.into_inner();
-        let socks5_stream: Socks5Stream<_> = buffered_socks5_stream.into_inner();
+        let socks5_stream = client.into_inner();
 
         let tls_stream = wrap_tls(strict_tls, hostname, socks5_stream)
             .await
             .context("STARTTLS upgrade failed")?;
         let buffered_stream = BufWriter::new(tls_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let client = Client::new(session_stream);
-        Ok(client)
+        let client = ImapClient::new(session_stream);
+
+        Ok(Client { inner: client })
     }
 }

src/imap/idle.rs

@@ -7,9 +7,7 @@ use futures_lite::FutureExt;
 
 use super::session::Session;
 use super::Imap;
-use crate::config::Config;
 use crate::imap::{client::IMAP_TIMEOUT, FolderMeaning};
-use crate::log::LogExt;
 use crate::{context::Context, scheduler::InterruptInfo};
 
 const IDLE_TIMEOUT: Duration = Duration::from_secs(23 * 60);
@@ -23,10 +21,6 @@ impl Session {
     ) -> Result<(Self, InterruptInfo)> {
         use futures::future::FutureExt;
 
-        if context.get_config_bool(Config::DisableIdle).await? {
-            bail!("IMAP IDLE is disabled");
-        }
-
         if !self.can_idle() {
             bail!("IMAP server does not have IDLE capability");
         }
@@ -169,14 +163,7 @@ impl Imap {
                         continue;
                     }
                     if let Some(session) = &self.session {
-                        if session.can_idle()
-                            && !context
-                                .get_config_bool(Config::DisableIdle)
-                                .await
-                                .context("Failed to get disable_idle config")
-                                .log_err(context)
-                                .unwrap_or_default()
-                        {
+                        if session.can_idle() {
                             // we only fake-idled because network was gone during IDLE, probably
                             break InterruptInfo::new(false);
                         }

src/imex.rs

@@ -58,7 +58,8 @@ pub enum ImexMode {
     /// Export a backup to the directory given as `path` with the given `passphrase`.
     /// The backup contains all contacts, chats, images and other data and device independent settings.
     /// The backup does not contain device dependent settings as ringtones or LED notification settings.
-    /// The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.tar`.
+    /// The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
+    /// the format is `delta-chat-<day>-<number>.tar`
     ExportBackup = 11,
 
     /// `path` is the file (not: directory) to import. The file is normally
@@ -127,7 +128,7 @@ pub async fn has_backup(_context: &Context, dir_name: &Path) -> Result<String> {
             && (newest_backup_name.is_empty() || name > newest_backup_name)
         {
             // We just use string comparison to determine which backup is newer.
-            // This works fine because the filenames have the form `delta-chat-backup-2023-10-18-00-foo@example.com.tar`
+            // This works fine because the filenames have the form ...delta-chat-backup-2020-07-24-00.tar
             newest_backup_path = Some(path);
             newest_backup_name = name;
         }
@@ -483,11 +484,7 @@ async fn import_backup(
 /// Returns Ok((temp_db_path, temp_path, dest_path)) on success. Unencrypted database can be
 /// written to temp_db_path. The backup can then be written to temp_path. If the backup succeeded,
 /// it can be renamed to dest_path. This guarantees that the backup is complete.
-fn get_next_backup_path(
-    folder: &Path,
-    addr: &str,
-    backup_time: i64,
-) -> Result<(PathBuf, PathBuf, PathBuf)> {
+fn get_next_backup_path(folder: &Path, backup_time: i64) -> Result<(PathBuf, PathBuf, PathBuf)> {
     let folder = PathBuf::from(folder);
     let stem = chrono::NaiveDateTime::from_timestamp_opt(backup_time, 0)
         .context("can't get next backup path")?
@@ -498,13 +495,13 @@ fn get_next_backup_path(
     // 64 backup files per day should be enough for everyone
     for i in 0..64 {
         let mut tempdbfile = folder.clone();
-        tempdbfile.push(format!("{stem}-{i:02}-{addr}.db"));
+        tempdbfile.push(format!("{stem}-{i:02}.db"));
 
         let mut tempfile = folder.clone();
-        tempfile.push(format!("{stem}-{i:02}-{addr}.tar.part"));
+        tempfile.push(format!("{stem}-{i:02}.tar.part"));
 
         let mut destfile = folder.clone();
-        destfile.push(format!("{stem}-{i:02}-{addr}.tar"));
+        destfile.push(format!("{stem}-{i:02}.tar"));
 
         if !tempdbfile.exists() && !tempfile.exists() && !destfile.exists() {
             return Ok((tempdbfile, tempfile, destfile));
@@ -519,8 +516,7 @@ fn get_next_backup_path(
 async fn export_backup(context: &Context, dir: &Path, passphrase: String) -> Result<()> {
     // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
     let now = time();
-    let self_addr = context.get_primary_self_addr().await?;
-    let (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, &self_addr, now)?;
+    let (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, now)?;
     let _d1 = DeleteOnDrop(temp_db_path.clone());
     let _d2 = DeleteOnDrop(temp_path.clone());
 

src/job.rs

@@ -0,0 +1,390 @@
+//! # Job module.
+//!
+//! This module implements a job queue maintained in the SQLite database
+//! and job types.
+
+#![allow(missing_docs)]
+
+use std::fmt;
+use std::sync::atomic::Ordering;
+
+use anyhow::{Context as _, Result};
+use deltachat_derive::{FromSql, ToSql};
+use rand::{thread_rng, Rng};
+
+use crate::context::Context;
+use crate::imap::Imap;
+use crate::scheduler::InterruptInfo;
+use crate::tools::time;
+
+// results in ~3 weeks for the last backoff timespan
+const JOB_RETRIES: u32 = 17;
+
+/// Job try result.
+#[derive(Debug, Display)]
+pub enum Status {
+    Finished(Result<()>),
+    RetryNow,
+}
+
+#[macro_export]
+macro_rules! job_try {
+    ($expr:expr) => {
+        match $expr {
+            std::result::Result::Ok(val) => val,
+            std::result::Result::Err(err) => {
+                return $crate::job::Status::Finished(Err(err.into()));
+            }
+        }
+    };
+    ($expr:expr,) => {
+        $crate::job_try!($expr)
+    };
+}
+
+#[derive(
+    Debug,
+    Display,
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    FromPrimitive,
+    ToPrimitive,
+    FromSql,
+    ToSql,
+)]
+#[repr(u32)]
+pub enum Action {
+    // This job will download partially downloaded messages completely
+    // and is added when download_full() is called.
+    // Most messages are downloaded automatically on fetch
+    // and do not go through this job.
+    DownloadMsg = 250,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Job {
+    pub job_id: u32,
+    pub action: Action,
+    pub foreign_id: u32,
+    pub desired_timestamp: i64,
+    pub added_timestamp: i64,
+    pub tries: u32,
+}
+
+impl fmt::Display for Job {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "#{}, action {}", self.job_id, self.action)
+    }
+}
+
+impl Job {
+    pub fn new(action: Action, foreign_id: u32) -> Self {
+        let timestamp = time();
+
+        Self {
+            job_id: 0,
+            action,
+            foreign_id,
+            desired_timestamp: timestamp,
+            added_timestamp: timestamp,
+            tries: 0,
+        }
+    }
+
+    /// Deletes the job from the database.
+    async fn delete(self, context: &Context) -> Result<()> {
+        if self.job_id != 0 {
+            context
+                .sql
+                .execute("DELETE FROM jobs WHERE id=?;", (self.job_id as i32,))
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    /// Saves the job to the database, creating a new entry if necessary.
+    ///
+    /// The Job is consumed by this method.
+    pub(crate) async fn save(self, context: &Context) -> Result<()> {
+        info!(context, "saving job {:?}", self);
+
+        if self.job_id != 0 {
+            context
+                .sql
+                .execute(
+                    "UPDATE jobs SET desired_timestamp=?, tries=? WHERE id=?;",
+                    (
+                        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 (?,?,?,?);",
+                (
+                    self.added_timestamp,
+                    self.action,
+                    self.foreign_id,
+                    self.desired_timestamp
+                )
+            ).await?;
+        }
+
+        Ok(())
+    }
+}
+
+pub(crate) enum Connection<'a> {
+    Inbox(&'a mut Imap),
+}
+
+impl<'a> Connection<'a> {
+    fn inbox(&mut self) -> &mut Imap {
+        match self {
+            Connection::Inbox(imap) => imap,
+        }
+    }
+}
+
+pub(crate) async fn perform_job(context: &Context, mut connection: Connection<'_>, mut job: Job) {
+    info!(context, "Job {} started...", &job);
+
+    let try_res = match perform_job_action(context, &job, &mut connection, 0).await {
+        Status::RetryNow => perform_job_action(context, &job, &mut connection, 1).await,
+        x => x,
+    };
+
+    match try_res {
+        Status::RetryNow => {
+            let tries = job.tries + 1;
+
+            if tries < JOB_RETRIES {
+                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;
+                info!(
+                    context,
+                    "job #{} not succeeded on try #{}, retry in {} seconds.",
+                    job.job_id,
+                    tries,
+                    time_offset
+                );
+                job.save(context).await.unwrap_or_else(|err| {
+                    error!(context, "Failed to save job: {err:#}.");
+                });
+            } else {
+                info!(
+                    context,
+                    "Remove job {job} as it exhausted {JOB_RETRIES} retries."
+                );
+                job.delete(context).await.unwrap_or_else(|err| {
+                    error!(context, "Failed to delete job: {err:#}.");
+                });
+            }
+        }
+        Status::Finished(res) => {
+            if let Err(err) = res {
+                warn!(context, "Remove job {job} as it failed with error {err:#}.");
+            } else {
+                info!(context, "Remove job {job} as it succeeded.");
+            }
+
+            job.delete(context).await.unwrap_or_else(|err| {
+                error!(context, "failed to delete job: {:#}", err);
+            });
+        }
+    }
+}
+
+async fn perform_job_action(
+    context: &Context,
+    job: &Job,
+    connection: &mut Connection<'_>,
+    tries: u32,
+) -> Status {
+    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 {tries} of job {job}.");
+
+    try_res
+}
+
+fn get_backoff_time_offset(tries: u32) -> i64 {
+    // Exponential backoff
+    let n = 2_i32.pow(tries - 1) * 60;
+    let mut rng = thread_rng();
+    let r: i32 = rng.gen();
+    let mut seconds = r % (n + 1);
+    if seconds < 1 {
+        seconds = 1;
+    }
+    i64::from(seconds)
+}
+
+pub(crate) async fn schedule_resync(context: &Context) -> Result<()> {
+    context.resync_request.store(true, Ordering::Relaxed);
+    context
+        .scheduler
+        .interrupt_inbox(InterruptInfo {
+            probe_network: false,
+        })
+        .await;
+    Ok(())
+}
+
+/// Adds a job to the database, scheduling it.
+pub async fn add(context: &Context, job: Job) -> Result<()> {
+    job.save(context).await.context("failed to save job")?;
+
+    info!(context, "Interrupt: IMAP.");
+    context
+        .scheduler
+        .interrupt_inbox(InterruptInfo::new(false))
+        .await;
+    Ok(())
+}
+
+/// Load jobs from the database.
+///
+/// The `probe_network` parameter decides how to query
+/// 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.");
+
+    let query;
+    let params;
+    let t = time();
+
+    if !info.probe_network {
+        // processing for first-try and after backoff-timeouts:
+        // process jobs in the order they were added.
+        query = r#"
+SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries
+FROM jobs
+WHERE desired_timestamp<=?
+ORDER BY action DESC, added_timestamp
+LIMIT 1;
+"#;
+        params = vec![t];
+    } else {
+        // processing after call to dc_maybe_network():
+        // process _all_ pending jobs that failed before
+        // in the order of their backoff-times.
+        query = r#"
+SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries
+FROM jobs
+WHERE tries>0
+ORDER BY desired_timestamp, action DESC
+LIMIT 1;
+"#;
+        params = vec![];
+    };
+
+    loop {
+        let job_res = context
+            .sql
+            .query_row_optional(query, rusqlite::params_from_iter(params.clone()), |row| {
+                let job = Job {
+                    job_id: row.get("id")?,
+                    action: row.get("action")?,
+                    foreign_id: row.get("foreign_id")?,
+                    desired_timestamp: row.get("desired_timestamp")?,
+                    added_timestamp: row.get("added_timestamp")?,
+                    tries: row.get("tries")?,
+                };
+
+                Ok(job)
+            })
+            .await;
+
+        match job_res {
+            Ok(job) => return Ok(job),
+            Err(err) => {
+                // Remove invalid job from the DB
+                info!(context, "Cleaning up job, because of {err:#}.");
+
+                // TODO: improve by only doing a single query
+                let id = context
+                    .sql
+                    .query_row(query, rusqlite::params_from_iter(params.clone()), |row| {
+                        row.get::<_, i32>(0)
+                    })
+                    .await
+                    .context("failed to retrieve invalid job ID from the database")?;
+                context
+                    .sql
+                    .execute("DELETE FROM jobs WHERE id=?;", (id,))
+                    .await
+                    .with_context(|| format!("failed to delete invalid job {id}"))?;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::TestContext;
+
+    async fn insert_job(context: &Context, foreign_id: i64, valid: bool) {
+        let now = time();
+        context
+            .sql
+            .execute(
+                "INSERT INTO jobs
+                   (added_timestamp, action, foreign_id, desired_timestamp)
+                 VALUES (?, ?, ?, ?);",
+                (
+                    now,
+                    if valid {
+                        Action::DownloadMsg as i32
+                    } else {
+                        -1
+                    },
+                    foreign_id,
+                    now,
+                ),
+            )
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_load_next_job_two() -> Result<()> {
+        // We want to ensure that loading jobs skips over jobs which
+        // fails to load from the database instead of failing to load
+        // all jobs.
+        let t = TestContext::new().await;
+        insert_job(&t, 1, false).await; // This can not be loaded into Job struct.
+        let jobs = load_next(&t, &InterruptInfo::new(false)).await?;
+        assert!(jobs.is_none());
+
+        insert_job(&t, 1, true).await;
+        let jobs = load_next(&t, &InterruptInfo::new(false)).await?;
+        assert!(jobs.is_some());
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_load_next_job_one() -> Result<()> {
+        let t = TestContext::new().await;
+
+        insert_job(&t, 1, true).await;
+
+        let jobs = load_next(&t, &InterruptInfo::new(false)).await?;
+        assert!(jobs.is_some());
+        Ok(())
+    }
+}

src/lib.rs

@@ -65,6 +65,10 @@ mod e2ee;
 pub mod ephemeral;
 mod imap;
 pub mod imex;
+pub mod release;
+mod scheduler;
+#[macro_use]
+mod job;
 pub mod key;
 mod keyring;
 pub mod location;
@@ -80,8 +84,6 @@ pub mod provider;
 pub mod qr;
 pub mod qr_code_generator;
 pub mod quota;
-pub mod release;
-mod scheduler;
 pub mod securejoin;
 mod simplify;
 mod smtp;

src/location.rs

@@ -328,13 +328,13 @@ pub async fn is_sending_locations_to_chat(
 }
 
 /// Sets current location of the user device.
-pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64) -> Result<bool> {
+pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64) -> bool {
     if latitude == 0.0 && longitude == 0.0 {
-        return Ok(true);
+        return true;
     }
     let mut continue_streaming = false;
 
-    let chats = context
+    if let Ok(chats) = context
         .sql
         .query_map(
             "SELECT id FROM chats WHERE locations_send_until>?;",
@@ -346,29 +346,33 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
                     .map_err(Into::into)
             },
         )
-        .await?;
-
-    for chat_id in chats {
-        context.sql.execute(
-                "INSERT INTO locations  \
-                 (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);",
-                 (
-                    latitude,
-                    longitude,
-                    accuracy,
-                    time(),
-                    chat_id,
-                    ContactId::SELF,
-                )).await.context("Failed to store location")?;
-
-        info!(context, "Stored location for chat {chat_id}.");
-        continue_streaming = true;
+        .await
+    {
+        for chat_id in chats {
+            if let Err(err) = context.sql.execute(
+                    "INSERT INTO locations  \
+                     (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);",
+                     (
+                        latitude,
+                        longitude,
+                        accuracy,
+                        time(),
+                        chat_id,
+                        ContactId::SELF,
+                    )
+            ).await {
+                warn!(context, "failed to store location {:#}", err);
+            } else {
+                info!(context, "stored location for chat {}", chat_id);
+                continue_streaming = true;
+            }
+        }
+        if continue_streaming {
+            context.emit_event(EventType::LocationChanged(Some(ContactId::SELF)));
+        };
     }
-    if continue_streaming {
-        context.emit_event(EventType::LocationChanged(Some(ContactId::SELF)));
-    };
 
-    Ok(continue_streaming)
+    continue_streaming
 }
 
 /// Searches for locations in the given time range, optionally filtering by chat and contact IDs.
@@ -460,7 +464,7 @@ pub async fn delete_all(context: &Context) -> Result<()> {
 }
 
 /// Returns `location.kml` contents.
-pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<Option<(String, u32)>> {
+pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)> {
     let mut last_added_location_id = 0;
 
     let self_addr = context.get_primary_self_addr().await?;
@@ -530,11 +534,9 @@ pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<Option<(Strin
         ret += "</Document>\n</kml>";
     }
 
-    if location_count > 0 {
-        Ok(Some((ret, last_added_location_id)))
-    } else {
-        Ok(None)
-    }
+    ensure!(location_count > 0, "No locations processed");
+
+    Ok((ret, last_added_location_id))
 }
 
 fn get_kml_timestamp(utc: i64) -> String {
@@ -926,38 +928,4 @@ Content-Disposition: attachment; filename="location.kml"
         assert_eq!(locations.len(), 1);
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_send_locations_to_chat() -> Result<()> {
-        let alice = TestContext::new_alice().await;
-        let bob = TestContext::new_bob().await;
-
-        let alice_chat = alice.create_chat(&bob).await;
-        send_locations_to_chat(&alice, alice_chat.id, 1000).await?;
-        let sent = alice.pop_sent_msg().await;
-        let msg = bob.recv_msg(&sent).await;
-        assert_eq!(msg.text, "Location streaming enabled by alice@example.org.");
-        let bob_chat_id = msg.chat_id;
-
-        assert_eq!(set(&alice, 10.0, 20.0, 1.0).await?, true);
-
-        // Send image without text.
-        let file_name = "image.png";
-        let bytes = include_bytes!("../test-data/image/logo.png");
-        let file = alice.get_blobdir().join(file_name);
-        tokio::fs::write(&file, bytes).await?;
-        let mut msg = Message::new(Viewtype::Image);
-        msg.set_file(file.to_str().unwrap(), None);
-        let sent = alice.send_msg(alice_chat.id, &mut msg).await;
-
-        let msg = bob.recv_msg_opt(&sent).await.unwrap();
-        assert!(msg.chat_id == bob_chat_id);
-        assert_eq!(msg.msg_ids.len(), 1);
-
-        let bob_msg = Message::load_from_db(&bob, *msg.msg_ids.get(0).unwrap()).await?;
-        assert_eq!(bob_msg.chat_id, bob_chat_id);
-        assert_eq!(bob_msg.viewtype, Viewtype::Image);
-
-        Ok(())
-    }
 }

src/mimefactory.rs

@@ -359,10 +359,9 @@ impl<'a> MimeFactory<'a> {
     async fn should_do_gossip(&self, context: &Context) -> Result<bool> {
         match &self.loaded {
             Loaded::Message { chat } => {
-                // beside key- and member-changes, force a periodic re-gossip.
+                // beside key- and member-changes, force re-gossip every 48 hours
                 let gossiped_timestamp = chat.id.get_gossiped_timestamp(context).await?;
-                let gossip_period = context.get_config_i64(Config::GossipPeriod).await?;
-                if time() >= gossiped_timestamp + gossip_period {
+                if time() > gossiped_timestamp + (2 * 24 * 60 * 60) {
                     Ok(true)
                 } else {
                     let cmd = self.msg.param.get_cmd();
@@ -415,9 +414,7 @@ impl<'a> MimeFactory<'a> {
                     return Ok(self.msg.subject.clone());
                 }
 
-                if (chat.typ == Chattype::Group || chat.typ == Chattype::Broadcast)
-                    && quoted_msg_subject.is_none_or_empty()
-                {
+                if chat.typ == Chattype::Group && quoted_msg_subject.is_none_or_empty() {
                     let re = if self.in_reply_to.is_empty() {
                         ""
                     } else {
@@ -426,13 +423,15 @@ impl<'a> MimeFactory<'a> {
                     return Ok(format!("{}{}", re, chat.name));
                 }
 
-                let parent_subject = if quoted_msg_subject.is_none_or_empty() {
-                    chat.param.get(Param::LastSubject)
-                } else {
-                    quoted_msg_subject.as_deref()
-                };
-                if let Some(last_subject) = parent_subject {
-                    return Ok(format!("Re: {}", remove_subject_prefix(last_subject)));
+                if chat.typ != Chattype::Broadcast {
+                    let parent_subject = if quoted_msg_subject.is_none_or_empty() {
+                        chat.param.get(Param::LastSubject)
+                    } else {
+                        quoted_msg_subject.as_deref()
+                    };
+                    if let Some(last_subject) = parent_subject {
+                        return Ok(format!("Re: {}", remove_subject_prefix(last_subject)));
+                    }
                 }
 
                 let self_name = &match context.get_config(Config::Displayname).await? {
@@ -594,15 +593,6 @@ impl<'a> MimeFactory<'a> {
             ));
         }
 
-        if let Loaded::Message { chat } = &self.loaded {
-            if chat.typ == Chattype::Broadcast {
-                headers.protected.push(Header::new(
-                    "List-ID".into(),
-                    format!("{} <{}>", chat.name, chat.grpid),
-                ));
-            }
-        }
-
         // Non-standard headers.
         headers
             .unprotected
@@ -688,12 +678,6 @@ impl<'a> MimeFactory<'a> {
                 })
         };
 
-        let get_content_type_directives_header = || {
-            (
-                "Content-Type-Deltachat-Directives".to_string(),
-                "protected-headers=\"v1\"".to_string(),
-            )
-        };
         let outer_message = if is_encrypted {
             headers.protected.push(from_header);
 
@@ -730,7 +714,10 @@ impl<'a> MimeFactory<'a> {
             if !existing_ct.ends_with(';') {
                 existing_ct += ";";
             }
-            let message = message.header(get_content_type_directives_header());
+            let message = message.replace_header(Header::new(
+                "Content-Type".to_string(),
+                format!("{existing_ct} protected-headers=\"v1\";"),
+            ));
 
             // Set the appropriate Content-Type for the outer message
             let outer_message = PartBuilder::new().header((
@@ -799,12 +786,11 @@ impl<'a> MimeFactory<'a> {
             {
                 message
             } else {
-                let message = message.header(get_content_type_directives_header());
                 let (payload, signature) = encrypt_helper.sign(context, message).await?;
                 PartBuilder::new()
                     .header((
-                        "Content-Type",
-                        "multipart/signed; protocol=\"application/pgp-signature\"",
+                        "Content-Type".to_string(),
+                        "multipart/signed; protocol=\"application/pgp-signature\"".to_string(),
                     ))
                     .child(payload)
                     .child(
@@ -874,13 +860,9 @@ impl<'a> MimeFactory<'a> {
     }
 
     /// Returns MIME part with a `location.kml` attachment.
-    async fn get_location_kml_part(&mut self, context: &Context) -> Result<Option<PartBuilder>> {
-        let Some((kml_content, last_added_location_id)) =
-            location::get_kml(context, self.msg.chat_id).await?
-        else {
-            return Ok(None);
-        };
-
+    async fn get_location_kml_part(&mut self, context: &Context) -> Result<PartBuilder> {
+        let (kml_content, last_added_location_id) =
+            location::get_kml(context, self.msg.chat_id).await?;
         let part = PartBuilder::new()
             .content_type(
                 &"application/vnd.google-earth.kml+xml"
@@ -896,7 +878,7 @@ impl<'a> MimeFactory<'a> {
             // otherwise, the independent location is already filed
             self.last_added_location_id = last_added_location_id;
         }
-        Ok(Some(part))
+        Ok(part)
     }
 
     #[allow(clippy::cognitive_complexity)]
@@ -1186,10 +1168,7 @@ impl<'a> MimeFactory<'a> {
         }
         let flowed_text = format_flowed(final_text);
 
-        let is_reaction = self.msg.param.get_int(Param::Reaction).unwrap_or_default() != 0;
-
-        let footer = if is_reaction { "" } else { &self.selfstatus };
-
+        let footer = &self.selfstatus;
         let message_text = format!(
             "{}{}{}{}{}{}",
             fwdhint.unwrap_or_default(),
@@ -1212,7 +1191,7 @@ impl<'a> MimeFactory<'a> {
             ))
             .body(message_text);
 
-        if is_reaction {
+        if self.msg.param.get_int(Param::Reaction).unwrap_or_default() != 0 {
             main_part = main_part.header(("Content-Disposition", "reaction"));
         }
 
@@ -1251,8 +1230,11 @@ impl<'a> MimeFactory<'a> {
         }
 
         if location::is_sending_locations_to_chat(context, Some(self.msg.chat_id)).await? {
-            if let Some(part) = self.get_location_kml_part(context).await? {
-                parts.push(part);
+            match self.get_location_kml_part(context).await {
+                Ok(part) => parts.push(part),
+                Err(err) => {
+                    warn!(context, "mimefactory: could not send location: {}", err);
+                }
             }
         }
 
@@ -1381,16 +1363,15 @@ impl<'a> MimeFactory<'a> {
     }
 }
 
-/// Returns base64-encoded buffer `buf` split into 76-bytes long
+/// Returns base64-encoded buffer `buf` split into 78-bytes long
 /// chunks separated by CRLF.
 ///
-/// [RFC2045 specification of base64 Content-Transfer-Encoding](https://datatracker.ietf.org/doc/html/rfc2045#section-6.8)
-/// says that "The encoded output stream must be represented in lines of no more than 76 characters each."
-/// Longer lines trigger `BASE64_LENGTH_78_79` rule of SpamAssassin.
+/// This line length limit is an
+/// [RFC5322 requirement](https://tools.ietf.org/html/rfc5322#section-2.1.1).
 pub(crate) fn wrapped_base64_encode(buf: &[u8]) -> String {
     let base64 = base64::engine::general_purpose::STANDARD.encode(buf);
     let mut chars = base64.chars();
-    std::iter::repeat_with(|| chars.by_ref().take(76).collect::<String>())
+    std::iter::repeat_with(|| chars.by_ref().take(78).collect::<String>())
         .take_while(|s| !s.is_empty())
         .collect::<Vec<_>>()
         .join("\r\n")
@@ -1549,7 +1530,6 @@ fn maybe_encode_words(words: &str) -> String {
 #[cfg(test)]
 mod tests {
     use mailparse::{addrparse_header, MailHeaderMap};
-    use std::str;
 
     use super::*;
     use crate::chat::ChatId;
@@ -1558,11 +1538,10 @@ mod tests {
         ProtectionStatus,
     };
     use crate::chatlist::Chatlist;
-    use crate::constants;
     use crate::contact::{ContactAddress, Origin};
     use crate::mimeparser::MimeMessage;
     use crate::receive_imf::receive_imf;
-    use crate::test_utils::{get_chat_msg, TestContext, TestContextManager};
+    use crate::test_utils::{get_chat_msg, TestContext};
     #[test]
     fn test_render_email_address() {
         let display_name = "ä space";
@@ -1632,8 +1611,8 @@ mod tests {
     fn test_wrapped_base64_encode() {
         let input = b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
         let output =
-            "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\r\n\
-             QUFBQUFBQUFBQQ==";
+            "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU\r\n\
+             FBQUFBQUFBQQ==";
         assert_eq!(wrapped_base64_encode(input), output);
     }
 
@@ -2211,11 +2190,7 @@ mod tests {
         assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 0);
 
         let part = payload.next().unwrap();
-        assert_eq!(
-            part.match_indices("multipart/mixed; protected-headers=\"v1\"")
-                .count(),
-            1
-        );
+        assert_eq!(part.match_indices("multipart/mixed").count(), 1);
         assert_eq!(part.match_indices("Subject:").count(), 1);
         assert_eq!(part.match_indices("Autocrypt:").count(), 0);
         assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 0);
@@ -2327,37 +2302,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_protected_headers_directive() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-        let chat = tcm
-            .send_recv_accept(&alice, &bob, "alice->bob")
-            .await
-            .chat_id;
-
-        // Now Bob can send an encrypted message to Alice.
-        let mut msg = Message::new(Viewtype::File);
-        // Long messages are truncated and MimeMessage::decoded_data is set for them. We need
-        // decoded_data to check presence of the necessary headers.
-        msg.set_text("a".repeat(constants::DC_DESIRED_TEXT_LEN + 1));
-        msg.set_file_from_bytes(&bob, "foo.bar", "content".as_bytes(), None)
-            .await?;
-        let sent = bob.send_msg(chat, &mut msg).await;
-        assert!(msg.get_showpadlock());
-
-        let mime = MimeMessage::from_bytes(&alice, sent.payload.as_bytes(), None).await?;
-        let mut payload = str::from_utf8(&mime.decoded_data)?.splitn(2, "\r\n\r\n");
-        let part = payload.next().unwrap();
-        assert_eq!(
-            part.match_indices("multipart/mixed; protected-headers=\"v1\"")
-                .count(),
-            1
-        );
-        assert_eq!(part.match_indices("Subject:").count(), 1);
-
-        Ok(())
-    }
 }

src/mimeparser.rs

@@ -110,7 +110,7 @@ pub(crate) struct MimeMessage {
 
     /// The decrypted, raw mime structure.
     ///
-    /// This is non-empty iff `is_mime_modified` and the message was actually encrypted. It is used
+    /// This is non-empty only if the message was actually encrypted.  It is used
     /// for e.g. late-parsing HTML.
     pub decoded_data: Vec<u8>,
 
@@ -123,6 +123,23 @@ pub(crate) enum AvatarAction {
     Change(String),
 }
 
+#[derive(Debug, PartialEq)]
+pub(crate) enum MailinglistType {
+    /// The message belongs to a mailing list and has a `ListId:`-header
+    /// that should be used to get a unique id.
+    ListIdBased,
+
+    /// The message belongs to a mailing list, but there is no `ListId:`-header;
+    /// `Sender:`-header should be used to get a unique id.
+    /// This method is used by implementations as Majordomo.
+    /// Note, that the `Sender:` header alone is not sufficient to detect these lists,
+    /// `get_mailinglist_type()` check additional conditions therefore.
+    SenderBased,
+
+    /// The message does not belong to a mailing list.
+    None,
+}
+
 /// System message type.
 #[derive(
     Debug, Default, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, ToSql, FromSql,
@@ -787,6 +804,18 @@ impl MimeMessage {
 
         // Boxed future to deal with recursion
         async move {
+            if mail.ctype.params.get("protected-headers").is_some() {
+                if mail.ctype.mimetype == "text/rfc822-headers" {
+                    warn!(
+                        context,
+                        "Protected headers found in text/rfc822-headers attachment: Will be ignored.",
+                    );
+                    return Ok(false);
+                }
+
+                warn!(context, "Ignoring nested protected headers");
+            }
+
             enum MimeS {
                 Multiple,
                 Single,
@@ -823,10 +852,7 @@ impl MimeMessage {
 
                     self.parse_mime_recursive(context, &mail, is_related).await
                 }
-                MimeS::Single => {
-                    self.add_single_part_if_known(context, mail, is_related)
-                        .await
-                }
+                MimeS::Single => self.add_single_part_if_known(context, mail, is_related).await,
             }
         }
         .boxed()
@@ -1323,28 +1349,26 @@ impl MimeMessage {
         self.parts.push(part);
     }
 
-    pub(crate) fn get_mailinglist_header(&self) -> Option<&str> {
-        if let Some(list_id) = self.get_header(HeaderDef::ListId) {
-            // The message belongs to a mailing list and has a `ListId:`-header
-            // that should be used to get a unique id.
-            return Some(list_id);
-        } else if let Some(sender) = self.get_header(HeaderDef::Sender) {
+    pub(crate) fn get_mailinglist_type(&self) -> MailinglistType {
+        if self.get_header(HeaderDef::ListId).is_some() {
+            return MailinglistType::ListIdBased;
+        } else if self.get_header(HeaderDef::Sender).is_some() {
             // the `Sender:`-header alone is no indicator for mailing list
             // as also used for bot-impersonation via `set_override_sender_name()`
             if let Some(precedence) = self.get_header(HeaderDef::Precedence) {
                 if precedence == "list" || precedence == "bulk" {
-                    // The message belongs to a mailing list, but there is no `ListId:`-header;
-                    // `Sender:`-header is be used to get a unique id.
-                    // This method is used by implementations as Majordomo.
-                    return Some(sender);
+                    return MailinglistType::SenderBased;
                 }
             }
         }
-        None
+        MailinglistType::None
     }
 
     pub(crate) fn is_mailinglist_message(&self) -> bool {
-        self.get_mailinglist_header().is_some()
+        match self.get_mailinglist_type() {
+            MailinglistType::ListIdBased | MailinglistType::SenderBased => true,
+            MailinglistType::None => false,
+        }
     }
 
     pub fn repl_msg_by_error(&mut self, error_msg: &str) {
@@ -1418,36 +1442,33 @@ impl MimeMessage {
         let (report_fields, _) = mailparse::parse_headers(&report_body)?;
 
         // must be present
-        if report_fields
-            .get_header_value(HeaderDef::Disposition)
-            .is_none()
-        {
-            warn!(
-                context,
-                "Ignoring unknown disposition-notification, Message-Id: {:?}.",
-                report_fields.get_header_value(HeaderDef::MessageId)
-            );
-            return Ok(None);
-        };
+        if let Some(_disposition) = report_fields.get_header_value(HeaderDef::Disposition) {
+            let original_message_id = report_fields
+                .get_header_value(HeaderDef::OriginalMessageId)
+                // MS Exchange doesn't add an Original-Message-Id header. Instead, they put
+                // the original message id into the In-Reply-To header:
+                .or_else(|| report.headers.get_header_value(HeaderDef::InReplyTo))
+                .and_then(|v| parse_message_id(&v).ok());
+            let additional_message_ids = report_fields
+                .get_header_value(HeaderDef::AdditionalMessageIds)
+                .map_or_else(Vec::new, |v| {
+                    v.split(' ')
+                        .filter_map(|s| parse_message_id(s).ok())
+                        .collect()
+                });
 
-        let original_message_id = report_fields
-            .get_header_value(HeaderDef::OriginalMessageId)
-            // MS Exchange doesn't add an Original-Message-Id header. Instead, they put
-            // the original message id into the In-Reply-To header:
-            .or_else(|| report.headers.get_header_value(HeaderDef::InReplyTo))
-            .and_then(|v| parse_message_id(&v).ok());
-        let additional_message_ids = report_fields
-            .get_header_value(HeaderDef::AdditionalMessageIds)
-            .map_or_else(Vec::new, |v| {
-                v.split(' ')
-                    .filter_map(|s| parse_message_id(s).ok())
-                    .collect()
-            });
+            return Ok(Some(Report {
+                original_message_id,
+                additional_message_ids,
+            }));
+        }
+        warn!(
+            context,
+            "ignoring unknown disposition-notification, Message-Id: {:?}",
+            report_fields.get_header_value(HeaderDef::MessageId)
+        );
 
-        Ok(Some(Report {
-            original_message_id,
-            additional_message_ids,
-        }))
+        Ok(None)
     }
 
     fn process_delivery_status(
@@ -1878,7 +1899,7 @@ fn get_mime_type(
             } else {
                 // Enacapsulated messages, see <https://www.w3.org/Protocols/rfc1341/7_3_Message.html>
                 // Also used as part "message/disposition-notification" of "multipart/report", which, however, will
-                // be handled separately.
+                // be handled separatedly.
                 // I've not seen any messages using this, so we do not attach these parts (maybe they're used to attach replies,
                 // which are unwanted at all).
                 // For now, we skip these parts at all; if desired, we could return DcMimeType::File/DC_MSG_File

src/net/http.rs

@@ -4,20 +4,12 @@ use std::time::Duration;
 
 use anyhow::{anyhow, Result};
 use mime::Mime;
-use once_cell::sync::Lazy;
 
 use crate::context::Context;
 use crate::socks::Socks5Config;
 
 const HTTP_TIMEOUT: Duration = Duration::from_secs(30);
 
-static LETSENCRYPT_ROOT: Lazy<reqwest::tls::Certificate> = Lazy::new(|| {
-    reqwest::tls::Certificate::from_der(include_bytes!(
-        "../../assets/root-certificates/letsencrypt/isrgrootx1.der"
-    ))
-    .unwrap()
-});
-
 /// HTTP(S) GET response.
 #[derive(Debug)]
 pub struct Response {
@@ -87,10 +79,7 @@ async fn read_url_inner(context: &Context, url: &str) -> Result<reqwest::Respons
 }
 
 pub(crate) fn get_client(socks5_config: Option<Socks5Config>) -> Result<reqwest::Client> {
-    let builder = reqwest::ClientBuilder::new()
-        .timeout(HTTP_TIMEOUT)
-        .add_root_certificate(LETSENCRYPT_ROOT.clone());
-
+    let builder = reqwest::ClientBuilder::new().timeout(HTTP_TIMEOUT);
     let builder = if let Some(socks5_config) = socks5_config {
         let proxy = reqwest::Proxy::all(socks5_config.to_url())?;
         builder.proxy(proxy)

src/peerstate.rs

@@ -21,7 +21,7 @@ use crate::stock_str;
 /// Type of the public key stored inside the peerstate.
 #[derive(Debug)]
 pub enum PeerstateKeyType {
-    /// Public key sent in the `Autocrypt-Gossip` header.
+    /// Pubilc key sent in the `Autocrypt-Gossip` header.
     GossipKey,
 
     /// Public key sent in the `Autocrypt` header.

src/provider.rs

@@ -8,7 +8,6 @@ use trust_dns_resolver::{config, AsyncResolver, TokioAsyncResolver};
 use crate::config::Config;
 use crate::context::Context;
 use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS};
-use crate::tools::EmailAddress;
 
 /// Provider status according to manual testing.
 #[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
@@ -176,30 +175,21 @@ fn get_resolver() -> Result<TokioAsyncResolver> {
     Ok(resolver)
 }
 
-/// Returns provider for the given an e-mail address.
-///
-/// Returns an error if provided address is not valid.
-pub async fn get_provider_info_by_addr(
-    context: &Context,
-    addr: &str,
-    skip_mx: bool,
-) -> Result<Option<&'static Provider>> {
-    let addr = EmailAddress::new(addr)?;
-
-    let provider = get_provider_info(context, &addr.domain, skip_mx).await;
-    Ok(provider)
-}
-
 /// Returns provider for the given domain.
 ///
 /// This function looks up domain in offline database first. If not
 /// found, it queries MX record for the domain and looks up offline
 /// database for MX domains.
+///
+/// For compatibility, email address can be passed to this function
+/// instead of the domain.
 pub async fn get_provider_info(
     context: &Context,
     domain: &str,
     skip_mx: bool,
 ) -> Option<&'static Provider> {
+    let domain = domain.rsplit('@').next()?;
+
     if let Some(provider) = get_provider_by_domain(domain) {
         return Some(provider);
     }
@@ -324,25 +314,15 @@ mod tests {
         let t = TestContext::new().await;
         assert!(get_provider_info(&t, "", false).await.is_none());
         assert!(get_provider_info(&t, "google.com", false).await.unwrap().id == "gmail");
-        assert!(get_provider_info(&t, "example@google.com", false)
-            .await
-            .is_none());
-    }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_get_provider_info_by_addr() -> Result<()> {
-        let t = TestContext::new().await;
-        assert!(get_provider_info_by_addr(&t, "google.com", false)
-            .await
-            .is_err());
+        // get_provider_info() accepts email addresses for backwards compatibility
         assert!(
-            get_provider_info_by_addr(&t, "example@google.com", false)
-                .await?
+            get_provider_info(&t, "example@google.com", false)
+                .await
                 .unwrap()
                 .id
                 == "gmail"
         );
-        Ok(())
     }
 
     #[test]

src/quota.rs

@@ -1,6 +1,7 @@
 //! # Support for IMAP QUOTA extension.
 
 use std::collections::BTreeMap;
+use std::sync::atomic::Ordering;
 
 use anyhow::{anyhow, Context as _, Result};
 use async_imap::types::{Quota, QuotaResource};
@@ -12,6 +13,7 @@ use crate::imap::scan_folders::get_watched_folders;
 use crate::imap::session::Session as ImapSession;
 use crate::imap::Imap;
 use crate::message::{Message, Viewtype};
+use crate::scheduler::InterruptInfo;
 use crate::tools::time;
 use crate::{stock_str, EventType};
 
@@ -32,12 +34,17 @@ pub const QUOTA_ERROR_THRESHOLD_PERCENTAGE: u64 = 95;
 /// providers report bad values and we would then spam the user.
 pub const QUOTA_ALLCLEAR_PERCENTAGE: u64 = 75;
 
+/// if recent quota is older,
+/// it is re-fetched on dc_get_connectivity_html()
+pub const QUOTA_MAX_AGE_SECONDS: i64 = 60;
+
 /// Server quota information with an update timestamp.
 #[derive(Debug)]
 pub struct QuotaInfo {
     /// Recently loaded quota information.
     /// set to `Err()` if the provider does not support quota or on other errors,
     /// set to `Ok()` for valid quota information.
+    /// Updated by `Action::UpdateRecentQuota`
     pub(crate) recent: Result<BTreeMap<String, Vec<QuotaResource>>>,
 
     /// Timestamp when structure was modified.
@@ -103,6 +110,18 @@ pub fn needs_quota_warning(curr_percentage: u64, warned_at_percentage: u64) -> b
 }
 
 impl Context {
+    // Adds a job to update `quota.recent`
+    pub(crate) async fn schedule_quota_update(&self) -> Result<()> {
+        let requested = self.quota_update_request.swap(true, Ordering::Relaxed);
+        if !requested {
+            // Quota update was not requested before.
+            self.scheduler
+                .interrupt_inbox(InterruptInfo::new(false))
+                .await;
+        }
+        Ok(())
+    }
+
     /// Updates `quota.recent`, sets `quota.modified` to the current time
     /// and emits an event to let the UIs update connectivity view.
     ///
@@ -111,6 +130,8 @@ impl Context {
     /// As the message is added only once, the user is not spammed
     /// in case for some providers the quota is always at ~100%
     /// and new space is allocated as needed.
+    ///
+    /// Called in response to `Action::UpdateRecentQuota`.
     pub(crate) async fn update_recent_quota(&self, imap: &mut Imap) -> Result<()> {
         if let Err(err) = imap.prepare(self).await {
             warn!(self, "could not connect: {:#}", err);
@@ -145,6 +166,9 @@ impl Context {
             }
         }
 
+        // Clear the request to update quota.
+        self.quota_update_request.store(false, Ordering::Relaxed);
+
         *self.quota.write().await = Some(QuotaInfo {
             recent: quota,
             modified: time(),

src/reaction.rs

@@ -431,32 +431,6 @@ Content-Disposition: reaction\n\
         assert_eq!(bob_reaction.emojis(), vec!["👍"]);
         assert_eq!(bob_reaction.as_str(), "👍");
 
-        // Alice receives reaction to her message from Bob with a footer.
-        receive_imf(
-            &alice,
-            "To: alice@example.org\n\
-From: bob@example.net\n\
-Date: Today, 29 February 2021 00:00:10 -800\n\
-Message-ID: 56790@example.net\n\
-In-Reply-To: 12345@example.org\n\
-Subject: Meeting\n\
-Mime-Version: 1.0 (1.0)\n\
-Content-Type: text/plain; charset=utf-8\n\
-Content-Disposition: reaction\n\
-\n\
-😀\n\
-\n\
---\n\
-_______________________________________________\n\
-Here's my footer -- bob@example.net"
-                .as_bytes(),
-            false,
-        )
-        .await?;
-
-        let reactions = get_msg_reactions(&alice, msg.id).await?;
-        assert_eq!(reactions.to_string(), "😀1");
-
         Ok(())
     }
 
@@ -490,16 +464,6 @@ Here's my footer -- bob@example.net"
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
 
-        // Test that the status does not get mixed up into reactions.
-        alice
-            .set_config(
-                Config::Selfstatus,
-                Some("Buy Delta Chat today and make this banner go away!"),
-            )
-            .await?;
-        bob.set_config(Config::Selfstatus, Some("Sent from my Delta Chat Pro. 👍"))
-            .await?;
-
         let chat_alice = alice.create_chat(&bob).await;
         let alice_msg = alice.send_text(chat_alice.id, "Hi!").await;
         let bob_msg = bob.recv_msg(&alice_msg).await;

src/receive_imf.rs

@@ -28,12 +28,13 @@ use crate::log::LogExt;
 use crate::message::{
     self, rfc724_mid_exists, Message, MessageState, MessengerMessage, MsgId, Viewtype,
 };
-use crate::mimeparser::{parse_message_ids, AvatarAction, MimeMessage, SystemMessage};
+use crate::mimeparser::{
+    parse_message_ids, AvatarAction, MailinglistType, MimeMessage, SystemMessage,
+};
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateKeyType, PeerstateVerifiedStatus};
 use crate::reaction::{set_msg_reaction, Reaction};
 use crate::securejoin::{self, handle_securejoin_handshake, observe_securejoin_on_other_device};
-use crate::simplify;
 use crate::sql;
 use crate::stock_str;
 use crate::tools::{
@@ -75,24 +76,6 @@ pub async fn receive_imf(
     let mail = parse_mail(imf_raw).context("can't parse mail")?;
     let rfc724_mid =
         imap::prefetch_get_message_id(&mail.headers).unwrap_or_else(imap::create_message_id);
-    if let Some(download_limit) = context.download_limit().await? {
-        let download_limit: usize = download_limit.try_into()?;
-        if imf_raw.len() > download_limit {
-            let head = std::str::from_utf8(imf_raw)?
-                .split("\r\n\r\n")
-                .next()
-                .context("No empty line in the message")?;
-            return receive_imf_inner(
-                context,
-                &rfc724_mid,
-                head.as_bytes(),
-                seen,
-                Some(imf_raw.len().try_into()?),
-                false,
-            )
-            .await;
-        }
-    }
     receive_imf_inner(context, &rfc724_mid, imf_raw, seen, None, false).await
 }
 
@@ -130,20 +113,21 @@ pub(crate) async fn receive_imf_inner(
     {
         Err(err) => {
             warn!(context, "receive_imf: can't parse MIME: {err:#}.");
-            if rfc724_mid.starts_with(GENERATED_PREFIX) {
-                // We don't have an rfc724_mid, there's no point in adding a trash entry
+            let msg_ids;
+            if !rfc724_mid.starts_with(GENERATED_PREFIX) {
+                let row_id = context
+                    .sql
+                    .execute(
+                        "INSERT INTO msgs(rfc724_mid, chat_id) VALUES (?,?)",
+                        (rfc724_mid, DC_CHAT_ID_TRASH),
+                    )
+                    .await?;
+                msg_ids = vec![MsgId::new(u32::try_from(row_id)?)];
+            } else {
                 return Ok(None);
+                // We don't have an rfc724_mid, there's no point in adding a trash entry
             }
 
-            let row_id = context
-                .sql
-                .execute(
-                    "INSERT INTO msgs(rfc724_mid, chat_id) VALUES (?,?)",
-                    (rfc724_mid, DC_CHAT_ID_TRASH),
-                )
-                .await?;
-            let msg_ids = vec![MsgId::new(u32::try_from(row_id)?)];
-
             return Ok(Some(ReceivedMsg {
                 chat_id: DC_CHAT_ID_TRASH,
                 state: MessageState::Undefined,
@@ -594,7 +578,6 @@ async fn add_parts(
             if let Some((new_chat_id, new_chat_id_blocked)) = create_or_lookup_group(
                 context,
                 mime_parser,
-                is_partial_download.is_some(),
                 if test_normal_chat.is_none() {
                     allow_creation
                 } else {
@@ -652,23 +635,45 @@ async fn add_parts(
 
         if chat_id.is_none() {
             // check if the message belongs to a mailing list
-            if let Some(mailinglist_header) = mime_parser.get_mailinglist_header() {
-                if let Some((new_chat_id, new_chat_id_blocked)) = create_or_lookup_mailinglist(
-                    context,
-                    allow_creation,
-                    mailinglist_header,
-                    mime_parser,
-                )
-                .await?
-                {
-                    chat_id = Some(new_chat_id);
-                    chat_id_blocked = new_chat_id_blocked;
+            match mime_parser.get_mailinglist_type() {
+                MailinglistType::ListIdBased => {
+                    if let Some(list_id) = mime_parser.get_header(HeaderDef::ListId) {
+                        if let Some((new_chat_id, new_chat_id_blocked)) =
+                            create_or_lookup_mailinglist(
+                                context,
+                                allow_creation,
+                                list_id,
+                                mime_parser,
+                            )
+                            .await?
+                        {
+                            chat_id = Some(new_chat_id);
+                            chat_id_blocked = new_chat_id_blocked;
+                        }
+                    }
                 }
+                MailinglistType::SenderBased => {
+                    if let Some(sender) = mime_parser.get_header(HeaderDef::Sender) {
+                        if let Some((new_chat_id, new_chat_id_blocked)) =
+                            create_or_lookup_mailinglist(
+                                context,
+                                allow_creation,
+                                sender,
+                                mime_parser,
+                            )
+                            .await?
+                        {
+                            chat_id = Some(new_chat_id);
+                            chat_id_blocked = new_chat_id_blocked;
+                        }
+                    }
+                }
+                MailinglistType::None => {}
             }
         }
 
         if let Some(chat_id) = chat_id {
-            apply_mailinglist_changes(context, mime_parser, sent_timestamp, chat_id).await?;
+            apply_mailinglist_changes(context, mime_parser, chat_id).await?;
         }
 
         // if contact renaming is prevented (for mailinglists and bots),
@@ -799,7 +804,6 @@ async fn add_parts(
                 if let Some((new_chat_id, new_chat_id_blocked)) = create_or_lookup_group(
                     context,
                     mime_parser,
-                    is_partial_download.is_some(),
                     allow_creation,
                     Blocked::Not,
                     from_id,
@@ -1089,13 +1093,12 @@ async fn add_parts(
 
     for part in &mut mime_parser.parts {
         if part.is_reaction {
-            let reaction_str = simplify::remove_footers(part.msg.as_str());
             set_msg_reaction(
                 context,
                 &mime_in_reply_to,
                 orig_chat_id.unwrap_or_default(),
                 from_id,
-                Reaction::from(reaction_str.as_str()),
+                Reaction::from(part.msg.as_str()),
             )
             .await?;
         }
@@ -1126,8 +1129,7 @@ async fn add_parts(
             (&part.msg, part.typ)
         };
 
-        let part_is_empty =
-            typ == Viewtype::Text && msg.is_empty() && part.param.get(Param::Quote).is_none();
+        let part_is_empty = part.msg.is_empty() && part.param.get(Param::Quote).is_none();
         let mime_modified = save_mime_modified && !part_is_empty;
         if mime_modified {
             // Avoid setting mime_modified for more than one part.
@@ -1152,8 +1154,7 @@ async fn add_parts(
 
         // If you change which information is skipped if the message is trashed,
         // also change `MsgId::trash()` and `delete_expired_messages()`
-        let trash =
-            chat_id.is_trash() || (is_location_kml && msg.is_empty() && typ == Viewtype::Text);
+        let trash = chat_id.is_trash() || (is_location_kml && msg.is_empty());
 
         let row_id = context
             .sql
@@ -1182,8 +1183,8 @@ INSERT INTO msgs
   )
 ON CONFLICT (id) DO UPDATE
 SET rfc724_mid=excluded.rfc724_mid, chat_id=excluded.chat_id,
-    from_id=excluded.from_id, to_id=excluded.to_id, timestamp_sent=excluded.timestamp_sent,
-    type=excluded.type, msgrmsg=excluded.msgrmsg,
+    from_id=excluded.from_id, to_id=excluded.to_id, timestamp=excluded.timestamp, timestamp_sent=excluded.timestamp_sent,
+    timestamp_rcvd=excluded.timestamp_rcvd, type=excluded.type, state=excluded.state, msgrmsg=excluded.msgrmsg,
     txt=excluded.txt, subject=excluded.subject, txt_raw=excluded.txt_raw, param=excluded.param,
     bytes=excluded.bytes, mime_headers=excluded.mime_headers,
     mime_compressed=excluded.mime_compressed, mime_in_reply_to=excluded.mime_in_reply_to,
@@ -1407,53 +1408,56 @@ async fn lookup_chat_by_reply(
 ) -> Result<Option<(ChatId, Blocked)>> {
     // Try to assign message to the same chat as the parent message.
 
-    let Some(parent) = parent else {
-        return Ok(None);
-    };
+    if let Some(parent) = parent {
+        let parent_chat = Chat::load_from_db(context, parent.chat_id).await?;
 
-    let parent_chat = Chat::load_from_db(context, parent.chat_id).await?;
-
-    if parent.download_state != DownloadState::Done
-        // TODO (2023-09-12): Added for backward compatibility with versions that did not have
-        // `DownloadState::Undecipherable`. Remove eventually with the comment in
-        // `MimeMessage::from_bytes()`.
-        || parent
-            .error
-            .as_ref()
-            .filter(|e| e.starts_with("Decrypting failed:"))
-            .is_some()
-    {
-        // If the parent msg is not fully downloaded or undecipherable, it may have been
-        // assigned to the wrong chat (they often get assigned to the 1:1 chat with the sender).
-        return Ok(None);
-    }
-
-    if parent_chat.id == DC_CHAT_ID_TRASH {
-        return Ok(None);
-    }
-
-    // If this was a private message just to self, it was probably a private reply.
-    // It should not go into the group then, but into the private chat.
-    if is_probably_private_reply(context, to_ids, from_id, mime_parser, parent_chat.id).await? {
-        return Ok(None);
-    }
-
-    // If the parent chat is a 1:1 chat, and the sender is a classical MUA and added
-    // a new person to TO/CC, then the message should not go to the 1:1 chat, but to a
-    // newly created ad-hoc group.
-    if parent_chat.typ == Chattype::Single && !mime_parser.has_chat_version() && to_ids.len() > 1 {
-        let mut chat_contacts = chat::get_chat_contacts(context, parent_chat.id).await?;
-        chat_contacts.push(ContactId::SELF);
-        if to_ids.iter().any(|id| !chat_contacts.contains(id)) {
+        if parent.download_state != DownloadState::Done
+            // TODO (2023-09-12): Added for backward compatibility with versions that did not have
+            // `DownloadState::Undecipherable`. Remove eventually with the comment in
+            // `MimeMessage::from_bytes()`.
+            || parent
+                .error
+                .as_ref()
+                .filter(|e| e.starts_with("Decrypting failed:"))
+                .is_some()
+        {
+            // If the parent msg is not fully downloaded or undecipherable, it may have been
+            // assigned to the wrong chat (they often get assigned to the 1:1 chat with the sender).
             return Ok(None);
         }
+
+        if parent_chat.id == DC_CHAT_ID_TRASH {
+            return Ok(None);
+        }
+
+        // If this was a private message just to self, it was probably a private reply.
+        // It should not go into the group then, but into the private chat.
+        if is_probably_private_reply(context, to_ids, from_id, mime_parser, parent_chat.id).await? {
+            return Ok(None);
+        }
+
+        // If the parent chat is a 1:1 chat, and the sender is a classical MUA and added
+        // a new person to TO/CC, then the message should not go to the 1:1 chat, but to a
+        // newly created ad-hoc group.
+        if parent_chat.typ == Chattype::Single
+            && !mime_parser.has_chat_version()
+            && to_ids.len() > 1
+        {
+            let mut chat_contacts = chat::get_chat_contacts(context, parent_chat.id).await?;
+            chat_contacts.push(ContactId::SELF);
+            if to_ids.iter().any(|id| !chat_contacts.contains(id)) {
+                return Ok(None);
+            }
+        }
+
+        info!(
+            context,
+            "Assigning message to {} as it's a reply to {}.", parent_chat.id, parent.rfc724_mid
+        );
+        return Ok(Some((parent_chat.id, parent_chat.blocked)));
     }
 
-    info!(
-        context,
-        "Assigning message to {} as it's a reply to {}.", parent_chat.id, parent.rfc724_mid
-    );
-    Ok(Some((parent_chat.id, parent_chat.blocked)))
+    Ok(None)
 }
 
 /// If this method returns true, the message shall be assigned to the 1:1 chat with the sender.
@@ -1496,7 +1500,6 @@ async fn is_probably_private_reply(
 async fn create_or_lookup_group(
     context: &Context,
     mime_parser: &mut MimeMessage,
-    is_partial_download: bool,
     allow_creation: bool,
     create_blocked: Blocked,
     from_id: ContactId,
@@ -1627,7 +1630,7 @@ async fn create_or_lookup_group(
 
     if let Some(chat_id) = chat_id {
         Ok(Some((chat_id, chat_id_blocked)))
-    } else if is_partial_download || mime_parser.decrypting_failed {
+    } else if mime_parser.decrypting_failed {
         // It is possible that the message was sent to a valid,
         // yet unknown group, which was rejected because
         // Chat-Group-Name, which is in the encrypted part, was
@@ -1660,7 +1663,7 @@ async fn apply_group_changes(
     }
 
     let mut send_event_chat_modified = false;
-    let (mut removed_id, mut added_id) = (None, None);
+    let mut removed_id = None;
     let mut better_msg = None;
 
     // True if a Delta Chat client has explicitly added our current primary address.
@@ -1671,9 +1674,8 @@ async fn apply_group_changes(
             false
         };
 
-    let mut chat_contacts = HashSet::from_iter(chat::get_chat_contacts(context, chat_id).await?);
-    let is_from_in_chat =
-        !chat_contacts.contains(&ContactId::SELF) || chat_contacts.contains(&from_id);
+    let is_from_in_chat = !chat::is_contact_in_chat(context, chat_id, ContactId::SELF).await?
+        || chat::is_contact_in_chat(context, chat_id, from_id).await?;
 
     // Reject group membership changes from non-members and old changes.
     let allow_member_list_changes = is_from_in_chat
@@ -1683,10 +1685,12 @@ async fn apply_group_changes(
 
     // Whether to rebuild the member list from scratch.
     let recreate_member_list = {
-        // Always recreate membership list if SELF has been added. The older versions of DC
-        // don't always set "In-Reply-To" to the latest message they sent, but to the latest
-        // delivered message (so it's a race), so we have this heuristic here.
-        self_added
+        // Recreate member list if the message comes from a MUA as these messages do _not_ set add/remove headers.
+        !mime_parser.has_chat_version()
+            // Always recreate membership list if SELF has been added. The older versions of DC
+            // don't always set "In-Reply-To" to the latest message they sent, but to the latest
+            // delivered message (so it's a race), so we have this heuristic here.
+            || self_added
             || match mime_parser.get_header(HeaderDef::InReplyTo) {
                 // If we don't know the referenced message, we missed some messages.
                 // Maybe they added/removed members, so we need to recreate our member list.
@@ -1712,8 +1716,14 @@ async fn apply_group_changes(
             Some(stock_str::msg_del_member_local(context, removed_addr, from_id).await)
         };
 
-        if removed_id.is_some() {
-            if !allow_member_list_changes {
+        if let Some(contact_id) = removed_id {
+            if allow_member_list_changes {
+                // Remove a single member from the chat.
+                if !recreate_member_list {
+                    chat::remove_from_chat_contacts_table(context, chat_id, contact_id).await?;
+                    send_event_chat_modified = true;
+                }
+            } else {
                 info!(
                     context,
                     "Ignoring removal of {removed_addr:?} from {chat_id}."
@@ -1726,11 +1736,13 @@ async fn apply_group_changes(
         better_msg = Some(stock_str::msg_add_member_local(context, added_addr, from_id).await);
 
         if allow_member_list_changes {
+            // Add a single member to the chat.
             if !recreate_member_list {
                 if let Some(contact_id) =
                     Contact::lookup_id_by_addr(context, added_addr, Origin::Unknown).await?
                 {
-                    added_id = Some(contact_id);
+                    chat::add_to_chat_contacts_table(context, chat_id, &[contact_id]).await?;
+                    send_event_chat_modified = true;
                 } else {
                     warn!(context, "Added {added_addr:?} has no contact id.")
                 }
@@ -1797,76 +1809,46 @@ async fn apply_group_changes(
         }
     }
 
-    if allow_member_list_changes {
-        let mut new_members = HashSet::from_iter(to_ids.iter().copied());
-        new_members.insert(ContactId::SELF);
-        if !from_id.is_special() {
-            new_members.insert(from_id);
-        }
-
-        if !recreate_member_list {
-            let diff: HashSet<ContactId> =
-                chat_contacts.difference(&new_members).copied().collect();
-            // Only delete old contacts if the sender is not a classical MUA user:
-            // Classical MUA users usually don't intend to remove users from an email
-            // thread, so if they removed a recipient then it was probably by accident.
-            if mime_parser.has_chat_version() {
-                // This is what provides group membership consistency: we remove group members
-                // locally if we see a discrepancy with the "To" list in the received message as it
-                // is better for privacy than adding absent members locally. But it shouldn't be a
-                // big problem if somebody missed a member addition, because they will likely
-                // recreate the member list from the next received message. The problem occurs only
-                // if that "somebody" managed to reply earlier. Really, it's a problem for big
-                // groups with high message rate, but let it be for now.
-                if !diff.is_empty() {
-                    warn!(context, "Implicit removal of {diff:?} from chat {chat_id}.");
-                }
-                new_members = chat_contacts.difference(&diff).copied().collect();
-            } else {
-                new_members.extend(diff);
-            }
-        }
-        if let Some(removed_id) = removed_id {
-            new_members.remove(&removed_id);
-        }
-        if let Some(added_id) = added_id {
-            new_members.insert(added_id);
-        }
-        if recreate_member_list {
-            info!(
-                context,
-                "Recreating chat {chat_id} member list with {new_members:?}.",
-            );
-        }
-
-        if new_members != chat_contacts {
-            let new_members_ref = &new_members;
+    // Recreate the member list.
+    if recreate_member_list {
+        // Only delete old contacts if the sender is not a classical MUA user:
+        // Classical MUA users usually don't intend to remove users from an email
+        // thread, so if they removed a recipient then it was probably by accident.
+        if mime_parser.has_chat_version() {
             context
                 .sql
-                .transaction(move |transaction| {
-                    transaction
-                        .execute("DELETE FROM chats_contacts WHERE chat_id=?", (chat_id,))?;
-                    for contact_id in new_members_ref {
-                        transaction.execute(
-                            "INSERT INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)",
-                            (chat_id, contact_id),
-                        )?;
-                    }
-                    Ok(())
-                })
+                .execute("DELETE FROM chats_contacts WHERE chat_id=?;", (chat_id,))
                 .await?;
-            chat_contacts = new_members;
-            send_event_chat_modified = true;
         }
+
+        let mut members_to_add = HashSet::new();
+        members_to_add.extend(to_ids);
+        members_to_add.insert(ContactId::SELF);
+
+        if !from_id.is_special() {
+            members_to_add.insert(from_id);
+        }
+
+        if let Some(removed_id) = removed_id {
+            members_to_add.remove(&removed_id);
+        }
+
+        info!(
+            context,
+            "Recreating chat {chat_id} with members {members_to_add:?}."
+        );
+
+        chat::add_to_chat_contacts_table(context, chat_id, &Vec::from_iter(members_to_add)).await?;
+        send_event_chat_modified = true;
     }
 
     if let Some(avatar_action) = &mime_parser.group_avatar {
-        if !chat_contacts.contains(&ContactId::SELF) {
+        if !chat::is_contact_in_chat(context, chat_id, ContactId::SELF).await? {
             warn!(
                 context,
                 "Received group avatar update for group chat {chat_id} we are not a member of."
             );
-        } else if !chat_contacts.contains(&from_id) {
+        } else if !chat::is_contact_in_chat(context, chat_id, from_id).await? {
             warn!(
                 context,
                 "Contact {from_id} attempts to modify group chat {chat_id} avatar without being a member.",
@@ -1897,8 +1879,6 @@ async fn apply_group_changes(
     Ok(better_msg)
 }
 
-static LIST_ID_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(.+)<(.+)>$").unwrap());
-
 /// Create or lookup a mailing list chat.
 ///
 /// `list_id_header` contains the Id that must be used for the mailing list
@@ -1915,71 +1895,23 @@ async fn create_or_lookup_mailinglist(
     list_id_header: &str,
     mime_parser: &MimeMessage,
 ) -> Result<Option<(ChatId, Blocked)>> {
-    let listid = match LIST_ID_REGEX.captures(list_id_header) {
-        Some(cap) => cap[2].trim().to_string(),
-        None => list_id_header
-            .trim()
-            .trim_start_matches('<')
-            .trim_end_matches('>')
-            .to_string(),
+    static LIST_ID: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(.+)<(.+)>$").unwrap());
+    let (mut name, listid) = match LIST_ID.captures(list_id_header) {
+        Some(cap) => (cap[1].trim().to_string(), cap[2].trim().to_string()),
+        None => (
+            "".to_string(),
+            list_id_header
+                .trim()
+                .trim_start_matches('<')
+                .trim_end_matches('>')
+                .to_string(),
+        ),
     };
 
     if let Some((chat_id, _, blocked)) = chat::get_chat_id_by_grpid(context, &listid).await? {
         return Ok(Some((chat_id, blocked)));
     }
 
-    let name = compute_mailinglist_name(list_id_header, &listid, mime_parser);
-
-    if allow_creation {
-        // list does not exist but should be created
-        let param = mime_parser.list_post.as_ref().map(|list_post| {
-            let mut p = Params::new();
-            p.set(Param::ListPost, list_post);
-            p.to_string()
-        });
-
-        let is_bot = context.get_config_bool(Config::Bot).await?;
-        let blocked = if is_bot {
-            Blocked::Not
-        } else {
-            Blocked::Request
-        };
-        let chat_id = ChatId::create_multiuser_record(
-            context,
-            Chattype::Mailinglist,
-            &listid,
-            &name,
-            blocked,
-            ProtectionStatus::Unprotected,
-            param,
-        )
-        .await
-        .with_context(|| {
-            format!(
-                "failed to create mailinglist '{}' for grpid={}",
-                &name, &listid
-            )
-        })?;
-
-        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.");
-        Ok(None)
-    }
-}
-
-#[allow(clippy::indexing_slicing)]
-fn compute_mailinglist_name(
-    list_id_header: &str,
-    listid: &str,
-    mime_parser: &MimeMessage,
-) -> String {
-    let mut name = match LIST_ID_REGEX.captures(list_id_header) {
-        Some(cap) => cap[1].trim().to_string(),
-        None => "".to_string(),
-    };
-
     // for mailchimp lists, the name in `ListId` is just a long number.
     // a usable name for these lists is in the `From` header
     // and we can detect these lists by a unique `ListId`-suffix.
@@ -2023,14 +1955,50 @@ fn compute_mailinglist_name(
         // 51231231231231231231231232869f58.xing.com -> xing.com
         static PREFIX_32_CHARS_HEX: Lazy<Regex> =
             Lazy::new(|| Regex::new(r"([0-9a-fA-F]{32})\.(.{6,})").unwrap());
-        if let Some(cap) = PREFIX_32_CHARS_HEX.captures(listid) {
+        if let Some(cap) = PREFIX_32_CHARS_HEX.captures(&listid) {
             name = cap[2].to_string();
         } else {
-            name = listid.to_string();
+            name = listid.clone();
         }
     }
 
-    strip_rtlo_characters(&name)
+    if allow_creation {
+        // list does not exist but should be created
+        let param = mime_parser.list_post.as_ref().map(|list_post| {
+            let mut p = Params::new();
+            p.set(Param::ListPost, list_post);
+            p.to_string()
+        });
+
+        let is_bot = context.get_config_bool(Config::Bot).await?;
+        let blocked = if is_bot {
+            Blocked::Not
+        } else {
+            Blocked::Request
+        };
+        let chat_id = ChatId::create_multiuser_record(
+            context,
+            Chattype::Mailinglist,
+            &listid,
+            &name,
+            blocked,
+            ProtectionStatus::Unprotected,
+            param,
+        )
+        .await
+        .with_context(|| {
+            format!(
+                "failed to create mailinglist '{}' for grpid={}",
+                &name, &listid
+            )
+        })?;
+
+        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.");
+        Ok(None)
+    }
 }
 
 /// Set ListId param on the contact and ListPost param the chat.
@@ -2039,61 +2007,41 @@ fn compute_mailinglist_name(
 async fn apply_mailinglist_changes(
     context: &Context,
     mime_parser: &MimeMessage,
-    sent_timestamp: i64,
     chat_id: ChatId,
 ) -> Result<()> {
-    let Some(mailinglist_header) = mime_parser.get_mailinglist_header() else {
-        return Ok(());
-    };
-
-    let mut chat = Chat::load_from_db(context, chat_id).await?;
-    if chat.typ != Chattype::Mailinglist {
-        return Ok(());
-    }
-    let listid = &chat.grpid;
-
-    let new_name = compute_mailinglist_name(mailinglist_header, listid, mime_parser);
-    if chat.name != new_name
-        && chat_id
-            .update_timestamp(context, Param::GroupNameTimestamp, sent_timestamp)
-            .await?
-    {
-        info!(context, "Updating listname for chat {chat_id}.");
-        context
-            .sql
-            .execute("UPDATE chats SET name=? WHERE id=?;", (new_name, chat_id))
-            .await?;
-        context.emit_event(EventType::ChatModified(chat_id));
-    }
-
-    let Some(list_post) = &mime_parser.list_post else {
-        return Ok(());
-    };
-
-    let list_post = match ContactAddress::new(list_post) {
-        Ok(list_post) => list_post,
-        Err(err) => {
-            warn!(context, "Invalid List-Post: {:#}.", err);
+    if let Some(list_post) = &mime_parser.list_post {
+        let mut chat = Chat::load_from_db(context, chat_id).await?;
+        if chat.typ != Chattype::Mailinglist {
             return Ok(());
         }
-    };
-    let (contact_id, _) = Contact::add_or_lookup(context, "", list_post, Origin::Hidden).await?;
-    let mut contact = Contact::get_by_id(context, contact_id).await?;
-    if contact.param.get(Param::ListId) != Some(listid) {
-        contact.param.set(Param::ListId, listid);
-        contact.update_param(context).await?;
-    }
+        let listid = &chat.grpid;
 
-    if let Some(old_list_post) = chat.param.get(Param::ListPost) {
-        if list_post.as_ref() != old_list_post {
-            // Apparently the mailing list is using a different List-Post header in each message.
-            // Make the mailing list read-only because we wouldn't know which message the user wants to reply to.
-            chat.param.remove(Param::ListPost);
+        let list_post = match ContactAddress::new(list_post) {
+            Ok(list_post) => list_post,
+            Err(err) => {
+                warn!(context, "Invalid List-Post: {:#}.", err);
+                return Ok(());
+            }
+        };
+        let (contact_id, _) =
+            Contact::add_or_lookup(context, "", list_post, Origin::Hidden).await?;
+        let mut contact = Contact::get_by_id(context, contact_id).await?;
+        if contact.param.get(Param::ListId) != Some(listid) {
+            contact.param.set(Param::ListId, listid);
+            contact.update_param(context).await?;
+        }
+
+        if let Some(old_list_post) = chat.param.get(Param::ListPost) {
+            if list_post.as_ref() != old_list_post {
+                // Apparently the mailing list is using a different List-Post header in each message.
+                // Make the mailing list read-only because we wouldn't know which message the user wants to reply to.
+                chat.param.remove(Param::ListPost);
+                chat.update_param(context).await?;
+            }
+        } else {
+            chat.param.set(Param::ListPost, list_post);
             chat.update_param(context).await?;
         }
-    } else {
-        chat.param.set(Param::ListPost, list_post);
-        chat.update_param(context).await?;
     }
 
     Ok(())

src/receive_imf/tests.rs

@@ -10,9 +10,8 @@ use crate::chat::{get_chat_msgs, ChatItem, ChatVisibility};
 use crate::chatlist::Chatlist;
 use crate::config::Config;
 use crate::constants::{DC_GCL_FOR_FORWARDING, DC_GCL_NO_SPECIALS};
-use crate::download::{DownloadState, MIN_DOWNLOAD_LIMIT};
 use crate::imap::prefetch_should_download;
-use crate::message::{self, Message};
+use crate::message::Message;
 use crate::test_utils::{get_chat_msg, TestContext, TestContextManager};
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -2974,7 +2973,6 @@ async fn test_auto_accept_for_bots() -> Result<()> {
     let msg = t.get_last_msg().await;
     let chat = chat::Chat::load_from_db(&t, msg.chat_id).await?;
     assert!(!chat.is_contact_request());
-    assert!(Contact::get_all(&t, 0, None).await?.len() == 1);
     Ok(())
 }
 
@@ -3371,14 +3369,19 @@ async fn test_dont_recreate_contacts_on_add_remove() -> Result<()> {
 
     alice.recv_msg(&bob.pop_sent_msg().await).await;
 
-    // Bob didn't receive the addition of Fiona, so Alice must remove Fiona from the members list
-    // back to make their group members view consistent.
-    assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 3);
+    // bob didn't receive the addition of fiona, but alice doesn't overwrite her own
+    // contact list with the one from bob which only has three members instead of four.
+    assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 4);
 
-    // Just a dumb check for remove_contact_from_chat(). Let's have it in this only place.
+    // bob removes a member.
     remove_contact_from_chat(&bob, bob_chat_id, bob_blue).await?;
+
     alice.recv_msg(&bob.pop_sent_msg().await).await;
-    assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 2);
+
+    // Bobs chat only has two members after the removal of blue, because he still
+    // didn't receive the addition of fiona. But that doesn't overwrite alice'
+    // memberlist.
+    assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 3);
 
     Ok(())
 }
@@ -3511,29 +3514,6 @@ async fn test_mua_cant_remove() -> Result<()> {
         chat::get_chat_contacts(&alice, group_chat.id).await?.len(),
         4
     );
-
-    // But if the parent message is missing, the message must goto a new ad-hoc group.
-    let bob_removes = receive_imf(
-        &alice,
-        b"Subject: Re: Message from alice\r\n\
-            From: <bob@example.net>\r\n\
-            To: <alice@example.org>, <claire@example.org>\r\n\
-            Date: Mon, 12 Dec 2022 14:32:40 +0000\r\n\
-            Message-ID: <bobs_answer_to_two_recipients_1@example.net>\r\n\
-            In-Reply-To: <Mr.missing@example.org>\r\n\
-            \r\n\
-            Hi back!\r\n",
-        false,
-    )
-    .await?
-    .unwrap();
-    assert_ne!(bob_removes.chat_id, alice_chat.id);
-    let group_chat = Chat::load_from_db(&alice, bob_removes.chat_id).await?;
-    assert_eq!(group_chat.typ, Chattype::Group);
-    assert_eq!(
-        chat::get_chat_contacts(&alice, group_chat.id).await?.len(),
-        3,
-    );
     Ok(())
 }
 
@@ -3699,114 +3679,3 @@ async fn test_keep_member_list_if_possibly_nomember() -> Result<()> {
     assert!(is_contact_in_chat(&bob, bob_chat_id, bob_alice_contact).await?);
     Ok(())
 }
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_download_later() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = tcm.alice().await;
-    alice.set_config(Config::DownloadLimit, Some("1")).await?;
-    assert_eq!(alice.download_limit().await?, Some(MIN_DOWNLOAD_LIMIT));
-
-    let bob = tcm.bob().await;
-    let bob_chat = bob.create_chat(&alice).await;
-    let text = String::from_utf8(vec![b'a'; MIN_DOWNLOAD_LIMIT as usize])?;
-    let sent_msg = bob.send_text(bob_chat.id, &text).await;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    assert_eq!(msg.state, MessageState::InFresh);
-
-    let hi_msg = tcm.send_recv(&bob, &alice, "hi").await;
-
-    alice.set_config(Config::DownloadLimit, None).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Done);
-    assert_eq!(msg.state, MessageState::InFresh);
-    assert_eq!(alice.get_last_msg_in(msg.chat_id).await.id, hi_msg.id);
-    assert!(msg.timestamp_sort <= hi_msg.timestamp_sort);
-
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_create_group_with_big_msg() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = tcm.alice().await;
-    let bob = tcm.bob().await;
-    let ba_contact = Contact::create(
-        &bob,
-        "alice",
-        &alice.get_config(Config::Addr).await?.unwrap(),
-    )
-    .await?;
-    let file_bytes = include_bytes!("../../test-data/image/screenshot.png");
-
-    let bob_grp_id = create_group_chat(&bob, ProtectionStatus::Unprotected, "Group").await?;
-    add_contact_to_chat(&bob, bob_grp_id, ba_contact).await?;
-    let mut msg = Message::new(Viewtype::Image);
-    msg.set_file_from_bytes(&bob, "a.jpg", file_bytes, None)
-        .await?;
-    let sent_msg = bob.send_msg(bob_grp_id, &mut msg).await;
-    assert!(!msg.get_showpadlock());
-
-    alice.set_config(Config::DownloadLimit, Some("1")).await?;
-    assert_eq!(alice.download_limit().await?, Some(MIN_DOWNLOAD_LIMIT));
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    let alice_grp = Chat::load_from_db(&alice, msg.chat_id).await?;
-    assert_eq!(alice_grp.typ, Chattype::Group);
-    assert_eq!(alice_grp.name, "Group");
-    assert_eq!(
-        chat::get_chat_contacts(&alice, alice_grp.id).await?.len(),
-        2
-    );
-
-    alice.set_config(Config::DownloadLimit, None).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Done);
-    assert_eq!(msg.state, MessageState::InFresh);
-    assert_eq!(msg.viewtype, Viewtype::Image);
-    assert_eq!(msg.chat_id, alice_grp.id);
-    let alice_grp = Chat::load_from_db(&alice, msg.chat_id).await?;
-    assert_eq!(alice_grp.typ, Chattype::Group);
-    assert_eq!(alice_grp.name, "Group");
-    assert_eq!(
-        chat::get_chat_contacts(&alice, alice_grp.id).await?.len(),
-        2
-    );
-
-    let ab_chat_id = tcm.send_recv_accept(&alice, &bob, "hi").await.chat_id;
-    // Now Bob can send encrypted messages to Alice.
-
-    let bob_grp_id = create_group_chat(&bob, ProtectionStatus::Unprotected, "Group1").await?;
-    add_contact_to_chat(&bob, bob_grp_id, ba_contact).await?;
-    let mut msg = Message::new(Viewtype::Image);
-    msg.set_file_from_bytes(&bob, "a.jpg", file_bytes, None)
-        .await?;
-    let sent_msg = bob.send_msg(bob_grp_id, &mut msg).await;
-    assert!(msg.get_showpadlock());
-
-    alice.set_config(Config::DownloadLimit, Some("1")).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    // Until fully downloaded, an encrypted message must sit in the 1:1 chat.
-    assert_eq!(msg.chat_id, ab_chat_id);
-
-    alice.set_config(Config::DownloadLimit, None).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Done);
-    assert_eq!(msg.state, MessageState::InFresh);
-    assert_eq!(msg.viewtype, Viewtype::Image);
-    assert_ne!(msg.chat_id, ab_chat_id);
-    let alice_grp = Chat::load_from_db(&alice, msg.chat_id).await?;
-    assert_eq!(alice_grp.typ, Chattype::Group);
-    assert_eq!(alice_grp.name, "Group1");
-    assert_eq!(
-        chat::get_chat_contacts(&alice, alice_grp.id).await?.len(),
-        2
-    );
-
-    // The big message must go away from the 1:1 chat.
-    assert_eq!(alice.get_last_msg_in(ab_chat_id).await.text, "hi");
-
-    Ok(())
-}

src/scheduler.rs

@@ -13,16 +13,16 @@ use self::connectivity::ConnectivityStore;
 use crate::config::Config;
 use crate::contact::{ContactId, RecentlySeenLoop};
 use crate::context::Context;
-use crate::download::download_msg;
 use crate::ephemeral::{self, delete_expired_imap_messages};
 use crate::events::EventType;
 use crate::imap::{FolderMeaning, Imap};
+use crate::job;
 use crate::location;
 use crate::log::LogExt;
-use crate::message::MsgId;
 use crate::smtp::{send_smtp_messages, Smtp};
 use crate::sql;
-use crate::tools::{duration_to_str, maybe_add_time_based_warnings, time};
+use crate::tools::time;
+use crate::tools::{duration_to_str, maybe_add_time_based_warnings};
 
 pub(crate) mod connectivity;
 
@@ -323,37 +323,6 @@ pub(crate) struct Scheduler {
     recently_seen_loop: RecentlySeenLoop,
 }
 
-async fn download_msgs(context: &Context, imap: &mut Imap) -> Result<()> {
-    let msg_ids = context
-        .sql
-        .query_map(
-            "SELECT msg_id FROM download",
-            (),
-            |row| {
-                let msg_id: MsgId = row.get(0)?;
-                Ok(msg_id)
-            },
-            |rowids| {
-                rowids
-                    .collect::<std::result::Result<Vec<_>, _>>()
-                    .map_err(Into::into)
-            },
-        )
-        .await?;
-
-    for msg_id in msg_ids {
-        if let Err(err) = download_msg(context, msg_id, imap).await {
-            warn!(context, "Failed to download message {msg_id}: {:#}.", err);
-        }
-        context
-            .sql
-            .execute("DELETE FROM download WHERE msg_id=?", (msg_id,))
-            .await?;
-    }
-
-    Ok(())
-}
-
 async fn inbox_loop(
     ctx: Context,
     started: oneshot::Sender<()>,
@@ -375,76 +344,79 @@ async fn inbox_loop(
             return;
         };
 
+        let mut info = InterruptInfo::default();
         loop {
-            {
-                // Update quota no more than once a minute.
-                let quota_needs_update = {
-                    let quota = ctx.quota.read().await;
-                    quota
-                        .as_ref()
-                        .filter(|quota| quota.modified + 60 > time())
-                        .is_none()
-                };
-
-                if quota_needs_update {
-                    if let Err(err) = ctx.update_recent_quota(&mut connection).await {
-                        warn!(ctx, "Failed to update quota: {:#}.", err);
-                    }
-                }
-            }
-
-            let resync_requested = ctx.resync_request.swap(false, Ordering::Relaxed);
-            if resync_requested {
-                if let Err(err) = connection.resync_folders(&ctx).await {
-                    warn!(ctx, "Failed to resync folders: {:#}.", err);
-                    ctx.resync_request.store(true, Ordering::Relaxed);
-                }
-            }
-
-            maybe_add_time_based_warnings(&ctx).await;
-
-            match ctx.get_config_i64(Config::LastHousekeeping).await {
-                Ok(last_housekeeping_time) => {
-                    let next_housekeeping_time =
-                        last_housekeeping_time.saturating_add(60 * 60 * 24);
-                    if next_housekeeping_time <= time() {
-                        sql::housekeeping(&ctx).await.log_err(&ctx).ok();
-                    }
-                }
+            let job = match job::load_next(&ctx, &info).await {
                 Err(err) => {
-                    warn!(ctx, "Failed to get last housekeeping time: {}", err);
+                    error!(ctx, "Failed loading job from the database: {:#}.", err);
+                    None
                 }
+                Ok(job) => job,
             };
 
-            match ctx.get_config_bool(Config::FetchedExistingMsgs).await {
-                Ok(fetched_existing_msgs) => {
-                    if !fetched_existing_msgs {
-                        // Consider it done even if we fail.
-                        //
-                        // This operation is not critical enough to retry,
-                        // especially if the error is persistent.
-                        if let Err(err) =
-                            ctx.set_config_bool(Config::FetchedExistingMsgs, true).await
-                        {
-                            warn!(ctx, "Can't set Config::FetchedExistingMsgs: {:#}", err);
-                        }
-
-                        if let Err(err) = connection.fetch_existing_msgs(&ctx).await {
-                            warn!(ctx, "Failed to fetch existing messages: {:#}", err);
-                            connection.trigger_reconnect(&ctx);
+            match job {
+                Some(job) => {
+                    job::perform_job(&ctx, job::Connection::Inbox(&mut connection), job).await;
+                    info = Default::default();
+                }
+                None => {
+                    let quota_requested = ctx.quota_update_request.swap(false, Ordering::Relaxed);
+                    if quota_requested {
+                        if let Err(err) = ctx.update_recent_quota(&mut connection).await {
+                            warn!(ctx, "Failed to update quota: {:#}.", err);
                         }
                     }
-                }
-                Err(err) => {
-                    warn!(ctx, "Can't get Config::FetchedExistingMsgs: {:#}", err);
+
+                    let resync_requested = ctx.resync_request.swap(false, Ordering::Relaxed);
+                    if resync_requested {
+                        if let Err(err) = connection.resync_folders(&ctx).await {
+                            warn!(ctx, "Failed to resync folders: {:#}.", err);
+                            ctx.resync_request.store(true, Ordering::Relaxed);
+                        }
+                    }
+
+                    maybe_add_time_based_warnings(&ctx).await;
+
+                    match ctx.get_config_i64(Config::LastHousekeeping).await {
+                        Ok(last_housekeeping_time) => {
+                            let next_housekeeping_time =
+                                last_housekeeping_time.saturating_add(60 * 60 * 24);
+                            if next_housekeeping_time <= time() {
+                                sql::housekeeping(&ctx).await.log_err(&ctx).ok();
+                            }
+                        }
+                        Err(err) => {
+                            warn!(ctx, "Failed to get last housekeeping time: {}", err);
+                        }
+                    };
+
+                    match ctx.get_config_bool(Config::FetchedExistingMsgs).await {
+                        Ok(fetched_existing_msgs) => {
+                            if !fetched_existing_msgs {
+                                // Consider it done even if we fail.
+                                //
+                                // This operation is not critical enough to retry,
+                                // especially if the error is persistent.
+                                if let Err(err) =
+                                    ctx.set_config_bool(Config::FetchedExistingMsgs, true).await
+                                {
+                                    warn!(ctx, "Can't set Config::FetchedExistingMsgs: {:#}", err);
+                                }
+
+                                if let Err(err) = connection.fetch_existing_msgs(&ctx).await {
+                                    warn!(ctx, "Failed to fetch existing messages: {:#}", err);
+                                    connection.trigger_reconnect(&ctx);
+                                }
+                            }
+                        }
+                        Err(err) => {
+                            warn!(ctx, "Can't get Config::FetchedExistingMsgs: {:#}", err);
+                        }
+                    }
+
+                    info = fetch_idle(&ctx, &mut connection, FolderMeaning::Inbox).await;
                 }
             }
-
-            if let Err(err) = download_msgs(&ctx, &mut connection).await {
-                warn!(ctx, "Failed to download messages: {:#}", err);
-            }
-
-            fetch_idle(&ctx, &mut connection, FolderMeaning::Inbox).await;
         }
     };
 
@@ -602,19 +574,6 @@ async fn fetch_idle(
                 .await;
         }
 
-        if ctx
-            .get_config_bool(Config::DisableIdle)
-            .await
-            .context("Failed to get disable_idle config")
-            .log_err(ctx)
-            .unwrap_or_default()
-        {
-            info!(ctx, "IMAP IDLE is disabled, going to fake idle.");
-            return connection
-                .fake_idle(ctx, Some(watch_folder), folder_meaning)
-                .await;
-        }
-
         info!(ctx, "IMAP session supports IDLE, using it.");
         match session
             .idle(

src/scheduler/connectivity.rs

@@ -1,5 +1,4 @@
 use core::fmt;
-use std::cmp::min;
 use std::{iter::once, ops::Deref, sync::Arc};
 
 use anyhow::{anyhow, Result};
@@ -8,7 +7,10 @@ use tokio::sync::Mutex;
 
 use crate::events::EventType;
 use crate::imap::{scan_folders::get_watched_folder_configs, FolderMeaning};
-use crate::quota::{QUOTA_ERROR_THRESHOLD_PERCENTAGE, QUOTA_WARN_THRESHOLD_PERCENTAGE};
+use crate::quota::{
+    QUOTA_ERROR_THRESHOLD_PERCENTAGE, QUOTA_MAX_AGE_SECONDS, QUOTA_WARN_THRESHOLD_PERCENTAGE,
+};
+use crate::tools::time;
 use crate::{context::Context, log::LogExt};
 use crate::{stock_str, tools};
 
@@ -455,8 +457,7 @@ impl Context {
                                 } else {
                                     "green"
                                 };
-                                let div_width_percent = min(100, percent);
-                                ret += &format!("<div class=\"bar\"><div class=\"progress {color}\" style=\"width: {div_width_percent}%\">{percent}%</div></div>");
+                                ret += &format!("<div class=\"bar\"><div class=\"progress {color}\" style=\"width: {percent}%\">{percent}%</div></div>");
 
                                 ret += "</li>";
                             }
@@ -469,9 +470,14 @@ impl Context {
                     ret += format!("<li>{e}</li>").as_str();
                 }
             }
+
+            if quota.modified + QUOTA_MAX_AGE_SECONDS < time() {
+                self.schedule_quota_update().await?;
+            }
         } else {
             let not_connected = stock_str::not_connected(self).await;
             ret += &format!("<li>{not_connected}</li>");
+            self.schedule_quota_update().await?;
         }
         ret += "</ul>";
 

src/simplify.rs

@@ -67,15 +67,6 @@ fn remove_nonstandard_footer<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
     (lines, false)
 }
 
-/// Remove footers if any.
-/// This also makes all newlines "\n", but why not.
-pub(crate) fn remove_footers(msg: &str) -> String {
-    let lines = split_lines(msg);
-    let lines = remove_message_footer(&lines).0;
-    let lines = remove_nonstandard_footer(lines).0;
-    lines.join("\n")
-}
-
 pub(crate) fn split_lines(buf: &str) -> Vec<&str> {
     buf.split('\n').collect()
 }

src/smtp.rs

@@ -673,14 +673,12 @@ pub(crate) async fn send_smtp_messages(context: &Context, connection: &mut Smtp)
 /// On failure returns an error without removing any `smtp_mdns` entries, the caller is responsible
 /// for removing the corresponding entry to prevent endless loop in case the entry is invalid, e.g.
 /// points to non-existent message or contact.
-///
-/// Returns true on success, false on temporary error.
 async fn send_mdn_msg_id(
     context: &Context,
     msg_id: MsgId,
     contact_id: ContactId,
     smtp: &mut Smtp,
-) -> Result<bool> {
+) -> Result<()> {
     let contact = Contact::get_by_id(context, contact_id).await?;
     if contact.is_blocked() {
         return Err(format_err!("Contact is blocked"));
@@ -732,14 +730,14 @@ async fn send_mdn_msg_id(
                     .execute(&q, rusqlite::params_from_iter(additional_msg_ids))
                     .await?;
             }
-            Ok(true)
+            Ok(())
         }
         SendResult::Retry => {
             info!(
                 context,
                 "Temporary SMTP failure while sending an MDN for {}", msg_id
             );
-            Ok(false)
+            Ok(())
         }
         SendResult::Failure(err) => Err(err),
     }
@@ -786,20 +784,15 @@ async fn send_mdn(context: &Context, smtp: &mut Smtp) -> Result<bool> {
         .await
         .context("failed to update MDN retries count")?;
 
-    let res = send_mdn_msg_id(context, msg_id, contact_id, smtp).await;
-    if let Err(ref err) = res {
+    if let Err(err) = send_mdn_msg_id(context, msg_id, contact_id, smtp).await {
         // If there is an error, for example there is no message corresponding to the msg_id in the
         // database, do not try to send this MDN again.
-        warn!(
-            context,
-            "Error sending MDN for {msg_id}, removing it: {err:#}."
-        );
         context
             .sql
             .execute("DELETE FROM smtp_mdns WHERE msg_id = ?", (msg_id,))
             .await?;
+        Err(err)
+    } else {
+        Ok(true)
     }
-    // If there's a temporary error, pretend there are no more MDNs to send. It's unlikely that
-    // other MDNs could be sent successfully in case of connectivity problems.
-    res
 }

src/sql.rs

@@ -686,7 +686,6 @@ fn new_connection(path: &Path, passphrase: &str) -> Result<Connection> {
          PRAGMA secure_delete=on;
          PRAGMA busy_timeout = 0; -- fail immediately
          PRAGMA temp_store=memory; -- Avoid SQLITE_IOERR_GETTEMPPATH errors on Android
-         PRAGMA soft_heap_limit = 8388608; -- 8 MiB limit, same as set in Android SQLiteDatabase.
          PRAGMA foreign_keys=on;
          ",
     )?;
@@ -742,6 +741,8 @@ pub async fn housekeeping(context: &Context) -> Result<()> {
         warn!(context, "Failed to deduplicate peerstates: {:#}.", err)
     }
 
+    context.schedule_quota_update().await?;
+
     // Try to clear the freelist to free some space on the disk. This
     // only works if auto_vacuum is enabled.
     match context

src/sql/migrations.rs

@@ -730,15 +730,6 @@ CREATE INDEX smtp_messageid ON imap(rfc724_mid);
         )
         .await?;
     }
-    if dbversion < 102 {
-        sql.execute_migration(
-            "CREATE TABLE download (
-            msg_id INTEGER NOT NULL -- id of the message stub in msgs table
-            )",
-            102,
-        )
-        .await?;
-    }
 
     let new_version = sql
         .get_raw_config_int(VERSION_CFG)

src/stock_str.rs

@@ -1550,7 +1550,7 @@ mod tests {
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
         assert_eq!(chats.len(), 0);
 
-        // a subsequent call to update_device_chats() must not re-add manually deleted messages or chats
+        // a subsequent call to update_device_chats() must not re-add manally deleted messages or chats
         t.update_device_chats().await.unwrap();
         let chats = Chatlist::try_load(&t, 0, None, None).await.unwrap();
         assert_eq!(chats.len(), 0);

src/test_utils.rs

@@ -108,15 +108,9 @@ impl TestContextManager {
     /// - Let one TestContext send a message
     /// - Let the other TestContext receive it and accept the chat
     /// - Assert that the message arrived
-    pub async fn send_recv_accept(
-        &self,
-        from: &TestContext,
-        to: &TestContext,
-        msg: &str,
-    ) -> Message {
+    pub async fn send_recv_accept(&self, from: &TestContext, to: &TestContext, msg: &str) {
         let received_msg = self.send_recv(from, to, msg).await;
         received_msg.chat_id.accept(to).await.unwrap();
-        received_msg
     }
 
     /// - Let one TestContext send a message

src/tools.rs

@@ -268,7 +268,7 @@ pub(crate) fn create_id() -> String {
 /// Function generates a Message-ID that can be used for a new outgoing message.
 /// - this function is called for all outgoing messages.
 /// - the message ID should be globally unique
-/// - do not add a counter or any private data as this leaks information unnecessarily
+/// - do not add a counter or any private data as this leaks information unncessarily
 pub(crate) fn create_outgoing_rfc724_mid(grpid: Option<&str>, from_addr: &str) -> String {
     let hostname = from_addr
         .find('@')
@@ -700,7 +700,7 @@ pub(crate) fn buf_decompress(buf: &[u8]) -> Result<Vec<u8>> {
 }
 
 const RTLO_CHARACTERS: [char; 5] = ['\u{202A}', '\u{202B}', '\u{202C}', '\u{202D}', '\u{202E}'];
-/// This method strips all occurrences of the RTLO Unicode character.
+/// This method strips all occurances of the RTLO Unicode character.
 /// [Why is this needed](https://github.com/deltachat/deltachat-core-rust/issues/3479)?
 pub(crate) fn strip_rtlo_characters(input_str: &str) -> String {
     input_str.replace(|char| RTLO_CHARACTERS.contains(&char), "")

src/webxdc.rs

@@ -26,6 +26,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tokio::io::AsyncReadExt;
 
+use crate::blob::BlobObject;
 use crate::chat::Chat;
 use crate::constants::Chattype;
 use crate::contact::ContactId;
@@ -845,6 +846,35 @@ impl Message {
     }
 }
 
+/// Replaces WebXDC blob of existing message.
+///
+/// This API is supposed to be called from within a WebXDC to replace itself
+/// e.g. with an updated or persistently reconfigured version.
+pub async fn replace_webxdc(context: &Context, msg_id: MsgId, data: &[u8]) -> Result<()> {
+    let mut msg = Message::load_from_db(context, msg_id).await?;
+
+    ensure!(
+        msg.get_viewtype() == Viewtype::Webxdc,
+        "Message {msg_id} is not a WebXDC instance"
+    );
+
+    let blob = BlobObject::create(
+        context,
+        &msg.get_filename()
+            .context("Cannot get filename of exising WebXDC instance")?,
+        data,
+    )
+    .await
+    .context("Failed to create WebXDC replacement blob")?;
+
+    let mut param = msg.param.clone();
+    param.set(Param::File, blob.as_name());
+    msg.param = param;
+    msg.update_param(context).await?;
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json::json;
@@ -1012,7 +1042,7 @@ mod tests {
         let instance = send_webxdc_instance(&t, chat_id).await?;
         t.send_webxdc_status_update(
             instance.id,
-            r#"{"info": "foo", "summary":"bar", "document":"doc", "payload": 42}"#,
+            r#"{"info": "foo", "summary":"bar", "payload": 42}"#,
             "descr",
         )
         .await?;
@@ -1020,7 +1050,7 @@ mod tests {
         assert_eq!(
             t.get_webxdc_status_updates(instance.id, StatusUpdateSerial(0))
                 .await?,
-            r#"[{"payload":42,"info":"foo","document":"doc","summary":"bar","serial":1,"max_serial":1}]"#
+            r#"[{"payload":42,"info":"foo","summary":"bar","serial":1,"max_serial":1}]"#
         );
         assert_eq!(chat_id.get_msg_cnt(&t).await?, 2); // instance and info
         let info = Message::load_from_db(&t, instance.id)
@@ -1028,7 +1058,6 @@ mod tests {
             .get_webxdc_info(&t)
             .await?;
         assert_eq!(info.summary, "bar".to_string());
-        assert_eq!(info.document, "doc".to_string());
 
         // forwarding an instance creates a fresh instance; updates etc. are not forwarded
         forward_msgs(&t, &[instance.get_id()], chat_id).await?;
@@ -1045,7 +1074,6 @@ mod tests {
             .get_webxdc_info(&t)
             .await?;
         assert_eq!(info.summary, "".to_string());
-        assert_eq!(info.document, "".to_string());
 
         Ok(())
     }
@@ -2625,4 +2653,62 @@ sth_for_the = "future""#
 
         Ok(())
     }
+
+    /// Tests replacing WebXDC with a newer version.
+    ///
+    /// Updates should be preserved after upgrading.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_replace_webxdc() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let bob = TestContext::new_bob().await;
+
+        // Alice sends WebXDC instance.
+        let alice_chat = alice.create_chat(&bob).await;
+        let mut alice_instance = create_webxdc_instance(
+            &alice,
+            "minimal.xdc",
+            include_bytes!("../test-data/webxdc/minimal.xdc"),
+        )
+        .await?;
+        alice_instance.set_text("user added text".to_string());
+        send_msg(&alice, alice_chat.id, &mut alice_instance).await?;
+        let alice_instance = alice.get_last_msg().await;
+        assert_eq!(alice_instance.get_text(), "user added text");
+
+        // Bob receives that instance.
+        let alice_sent_instance = alice.pop_sent_msg().await;
+        let bob_received_instance = bob.recv_msg(&alice_sent_instance).await;
+        assert_eq!(bob_received_instance.get_text(), "user added text");
+
+        // Alice sends WebXDC update.
+        alice
+            .send_webxdc_status_update(alice_instance.id, r#"{"payload": 1}"#, "Alice update")
+            .await?;
+        alice.flush_status_updates().await?;
+        let alice_sent_update = alice.pop_sent_msg().await;
+        bob.recv_msg(&alice_sent_update).await;
+        assert_eq!(
+            bob.get_webxdc_status_updates(bob_received_instance.id, StatusUpdateSerial(0))
+                .await?,
+            r#"[{"payload":1,"serial":1,"max_serial":1}]"#
+        );
+
+        // Bob replaces WebXDC.
+        replace_webxdc(
+            &bob,
+            bob_received_instance.id,
+            include_bytes!("../test-data/webxdc/with-minimal-manifest.xdc"),
+        )
+        .await
+        .context("Failed to replace WebXDC")?;
+
+        // Updates are not modified.
+        assert_eq!(
+            bob.get_webxdc_status_updates(bob_received_instance.id, StatusUpdateSerial(0))
+                .await?,
+            r#"[{"payload":1,"serial":1,"max_serial":1}]"#
+        );
+
+        Ok(())
+    }
 }