chore(release): prepare for 1.127.0

Even though r2d2 connection pool is removed,
deleting accounts still fails in Windows CI.

This reverts commit e88f21c010.
`try_many_times` documentation is modified to explain
why the workaround is still needed.

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ on:
   pull_request:
   push:
     branches:
-      - master
+      - main
 
 env:
   RUSTFLAGS: -Dwarnings
@@ -24,7 +24,7 @@ jobs:
     name: Lint Rust
     runs-on: ubuntu-latest
     env:
-      RUSTUP_TOOLCHAIN: 1.71.0
+      RUSTUP_TOOLCHAIN: 1.73.0
     steps:
       - uses: actions/checkout@v3
       - name: Install rustfmt and clippy
@@ -38,10 +38,6 @@ 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
@@ -80,15 +76,15 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            rust: 1.71.0
+            rust: 1.73.0
           - os: windows-latest
-            rust: 1.71.0
+            rust: 1.73.0
           - os: macos-latest
-            rust: 1.71.0
+            rust: 1.73.0
 
-          # Minimum Supported Rust Version = 1.67.0
+          # Minimum Supported Rust Version = 1.70.0
           - os: ubuntu-latest
-            rust: 1.67.0
+            rust: 1.70.0
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3
@@ -134,7 +130,7 @@ jobs:
     name: Build deltachat-rpc-server
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3
@@ -149,7 +145,7 @@ jobs:
         uses: actions/upload-artifact@v3
         with:
           name: ${{ matrix.os }}-deltachat-rpc-server
-          path: target/debug/deltachat-rpc-server
+          path: ${{ matrix.os == 'windows-latest' && 'target/debug/deltachat-rpc-server.exe' || 'target/debug/deltachat-rpc-server' }}
           retention-days: 1
 
   python_lint:
@@ -170,8 +166,8 @@ jobs:
         working-directory: deltachat-rpc-client
         run: tox -e lint
 
-  python_tests:
-    name: Python tests
+  cffi_python_tests:
+    name: CFFI Python tests
     needs: ["c_library", "python_lint"]
     strategy:
       fail-fast: false
@@ -179,15 +175,15 @@ jobs:
         include:
           # Currently used Rust version.
           - os: ubuntu-latest
-            python: 3.11
+            python: 3.12
           - os: macos-latest
-            python: 3.11
+            python: 3.12
 
           # PyPy tests
           - os: ubuntu-latest
-            python: pypy3.9
+            python: pypy3.10
           - os: macos-latest
-            python: pypy3.9
+            python: pypy3.10
 
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
@@ -205,12 +201,10 @@ jobs:
           name: ${{ matrix.os }}-libdeltachat.a
           path: target/debug
 
-      # TODO: Temporarily hardcode Python version to 3.7 until
-      # https://github.com/breathe-doc/breathe/issues/943 is done.
       - name: Install python
         uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: ${{ matrix.python }}
 
       - name: Install tox
         run: pip install tox
@@ -223,30 +217,29 @@ jobs:
         working-directory: python
         run: tox -e mypy,doc,py
 
-  aysnc_python_tests:
-    name: Async Python tests
+  rpc_python_tests:
+    name: JSON-RPC Python tests
     needs: ["python_lint", "rpc_server"]
     strategy:
       fail-fast: false
       matrix:
         include:
           - os: ubuntu-latest
-            python: 3.11
+            python: 3.12
           - os: macos-latest
-            python: 3.11
+            python: 3.12
+          - os: windows-latest
+            python: 3.12
 
           # PyPy tests
           - os: ubuntu-latest
-            python: pypy3.9
+            python: pypy3.10
           - os: macos-latest
-            python: pypy3.9
+            python: pypy3.10
 
-          # 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>
+          # Minimum Supported Python Version = 3.7
           - os: ubuntu-latest
-            python: 3.8
+            python: 3.7
 
     runs-on: ${{ matrix.os }}
     steps:
@@ -267,11 +260,18 @@ jobs:
           path: target/debug
 
       - name: Make deltachat-rpc-server executable
+        if: ${{ matrix.os != 'windows-latest' }}
         run: chmod +x target/debug/deltachat-rpc-server
 
       - name: Add deltachat-rpc-server to path
+        if: ${{ matrix.os != 'windows-latest' }}
         run: echo ${{ github.workspace }}/target/debug >> $GITHUB_PATH
 
+      - name: Add deltachat-rpc-server to path
+        if: ${{ matrix.os == 'windows-latest' }}
+        run: |
+          "${{ github.workspace }}/target/debug" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
       - name: Run deltachat-rpc-client tests
         env:
           DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}

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

@@ -26,35 +26,17 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Build
+      - name: Install ziglang
+        run: pip install wheel ziglang==0.11.0
+
+      - name: Build deltachat-rpc-server binaries
         run: sh scripts/zig-rpc-server.sh
 
-      - name: Upload x86_64 binary
+      - name: Upload dist directory with Linux binaries
         uses: actions/upload-artifact@v3
         with:
-          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
+          name: linux
+          path: dist/
           if-no-files-found: error
 
   build_windows:
@@ -92,39 +74,87 @@ 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 x86_64-apple-darwin
+        run: rustup target add ${{ matrix.arch }}-apple-darwin
 
       - name: Build
-        run: cargo build --release --package deltachat-rpc-server --target x86_64-apple-darwin --features vendored
+        run: cargo build --release --package deltachat-rpc-server --target ${{ matrix.arch }}-apple-darwin --features vendored
 
       - name: Upload binary
         uses: actions/upload-artifact@v3
         with:
-          name: deltachat-rpc-server-x86_64-macos
-          path: target/x86_64-apple-darwin/release/deltachat-rpc-server
+          name: deltachat-rpc-server-${{ matrix.arch }}-macos
+          path: target/${{ matrix.arch }}-apple-darwin/release/deltachat-rpc-server
           if-no-files-found: error
 
   publish:
-    name: Upload binaries to the release
+    name: Build wheels and upload binaries to the release
     needs: ["build_linux", "build_windows", "build_macos"]
     permissions:
       contents: write
     runs-on: "ubuntu-latest"
     steps:
-      - name: Download built binaries
-        uses: "actions/download-artifact@v3"
+      - uses: actions/checkout@v3
 
-      - name: Compose dist/ directory
+      - 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
         run: |
-          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
+          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
 
       - name: List downloaded artifacts
         run: ls -l dist/

.github/workflows/jsonrpc.yml

@@ -2,9 +2,9 @@ name: JSON-RPC API Test
 
 on:
   push:
-    branches: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
 
 env:
   CARGO_TERM_COLOR: always

.github/workflows/node-docs.yml

@@ -8,7 +8,7 @@ name: Generate & upload node.js documentation
 on:
   push:
     branches:
-      - master
+      - main
 
 jobs:
   generate:

.github/workflows/node-package.yml

@@ -67,7 +67,9 @@ jobs:
 
     # Build Linux prebuilds inside a container with old glibc for backwards compatibility.
     # Debian 10 contained glibc 2.28 at the time of the writing (2023-06-04): https://packages.debian.org/buster/libc6
-    container: debian:10
+    # Ubuntu 18.04 is at the End of Standard Support since June 2023, but it contains glibc 2.27,
+    # so we are using it to support Ubuntu 18.04 setups that are still not upgraded.
+    container: ubuntu:18.04
     steps:
       # Working directory is owned by 1001:1001 by default.
       # Change it to our user.

.github/workflows/node-tests.yml

@@ -13,7 +13,7 @@ on:
   pull_request:
   push:
     branches:
-      - master
+      - main
 
 jobs:
   tests:

.github/workflows/upload-docs.yml

@@ -3,8 +3,7 @@ name: Build & Deploy Documentation on rs.delta.chat
 on:
   push:
     branches:
-      - master
-      - docs-gh-action
+      - main
 
 jobs:
   build:

.github/workflows/upload-ffi-docs.yml

@@ -7,8 +7,7 @@ name: Build & Deploy Documentation on cffi.delta.chat
 on:
   push:
     branches:
-      - master
-      - docs-gh-action
+      - main
 
 jobs:
   build:

.gitignore

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

CHANGELOG.md

@@ -1,5 +1,307 @@
 # Changelog
 
+## [1.127.0] - 2023-10-26
+
+### API-Changes
+
+- [**breaking**] `dc_accounts_new` API is changed. Unused `os_name` argument is removed and `writable` argument is added.
+- jsonrpc: Add `resend_messages`.
+- [**breaking**] Remove unused function `is_verified_ex()` ([#4551](https://github.com/deltachat/deltachat-core-rust/pull/4551))
+- [**breaking**] Make `MsgId.delete_from_db()` private.
+- [**breaking**] deltachat-jsonrpc: use `kind` as a tag for all union types
+- json-rpc: Force stickers to be sent as stickers ([#4819](https://github.com/deltachat/deltachat-core-rust/pull/4819)).
+- Add mailto parse api ([#4829](https://github.com/deltachat/deltachat-core-rust/pull/4829)).
+- [**breaking**] Remove unused `DC_STR_PROTECTION_(EN)ABLED` strings
+- [**breaking**] Remove unused `dc_set_chat_protection()`
+- Hide `DcSecretKey` trait from the API.
+- Verified 1:1 chats ([#4315](https://github.com/deltachat/deltachat-core-rust/pull/4315)). Disabled by default, enable with `verified_one_on_one_chats` config.
+
+### CI
+
+- Run Rust tests with `RUST_BACKTRACE` set.
+- Replace `master` branch with `main`.  Run CI only on `main` branch pushes.
+- Test `deltachat-rpc-client` on Windows.
+
+### Documentation
+
+- Document how logs and error messages should be formatted in `CONTRIBUTING.md`.
+- Clarify transitive behaviour of `dc_contact_is_verfified()`.
+- Document `configured_addr`.
+
+### Features / Changes
+
+- Add lockfile to account manager ([#4314](https://github.com/deltachat/deltachat-core-rust/pull/4314)). 
+- Don't show a contact as verified if their key changed since the verification ([#4574](https://github.com/deltachat/deltachat-core-rust/pull/4574)).
+- deltachat-rpc-server: Add `--openrpc` option to print OpenRPC specification for JSON-RPC API. This specification can be used to generate JSON-RPC API clients.
+- Track whether contact is a bot or not ([#4821](https://github.com/deltachat/deltachat-core-rust/pull/4821)).
+- Replace `Config::SendSyncMsgs` with `SyncMsgs` ([#4817](https://github.com/deltachat/deltachat-core-rust/pull/4817)).
+
+### Fixes
+
+- Don't create 1:1 chat as protected for contact who doesn't prefer to encrypt ([#4538](https://github.com/deltachat/deltachat-core-rust/pull/4538)).
+- Allow to save a draft if the verification is broken ([#4542](https://github.com/deltachat/deltachat-core-rust/pull/4542)).
+- Fix info-message orderings of verified 1:1 chats ([#4545](https://github.com/deltachat/deltachat-core-rust/pull/4545)).
+- Fix example; this was changed some time ago, see https://docs.webxdc.org/spec.html#sendupdate
+- `receive_imf`: Update peerstate from db after handling Securejoin handshake ([#4600](https://github.com/deltachat/deltachat-core-rust/pull/4600)).
+- Sort old incoming messages below all outgoing ones ([#4621](https://github.com/deltachat/deltachat-core-rust/pull/4621)).
+- Do not mark non-verified group chats as verified when using securejoin.
+- `receive_imf`: Set protection only for Chattype::Single ([#4597](https://github.com/deltachat/deltachat-core-rust/pull/4597)).
+- Return from `dc_get_chatlist(DC_GCL_FOR_FORWARDING)` only chats where we can send ([#4616](https://github.com/deltachat/deltachat-core-rust/pull/4616)).
+- Clear VerifiedOneOnOneChats config on backup ([#4615](https://github.com/deltachat/deltachat-core-rust/pull/4615)).
+- Try removal of accounts multiple times with timeouts in case the database file is blocked (restore `try_many_times` workaround).
+
+### Build system
+
+- Remove examples/simple.rs.
+- Increase MSRV to 1.70.0.
+- Update dependencies.
+- Switch to iroh 0.4.x fork with updated dependencies.
+
+## [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
+
+- jsonrpc: Return only chat IDs for similar chats.
+
+### Fixes
+
+- Reopen all connections on database passpharse change.
+- Do not block new group chats if 1:1 chat is blocked.
+- Improve group membership consistency algorithm ([#3782](https://github.com/deltachat/deltachat-core-rust/pull/3782))([#4624](https://github.com/deltachat/deltachat-core-rust/pull/4624)).
+- Forbid membership changes from possible non-members ([#3782](https://github.com/deltachat/deltachat-core-rust/pull/3782)).
+- `ChatId::parent_query()`: Don't filter out OutPending and OutFailed messages.
+
+### Build system
+
+- Update to OpenSSL 3.0.
+- Bump webpki from 0.22.0 to 0.22.1.
+- python: Add link to Mastodon into projects.urls.
+
+### Features / Changes
+
+- Add RSA-4096 key generation support.
+
+### Refactor
+
+- pgp: Add constants for encryption algorithm and hash.
+
+## [1.121.0] - 2023-09-06
+
+### API-Changes
+
+- Add `dc_context_change_passphrase()`.
+- Add `Message.set_file_from_bytes()` API.
+- Add experimental API to get similar chats.
+
+### Build system
+
+- Build node packages on Ubuntu 18.04 instead of Debian 10.
+  This reduces the requirement for glibc version from 2.28 to 2.27.
+
+### Fixes
+
+- Allow membership changes by a MUA if we're not in the group ([#4624](https://github.com/deltachat/deltachat-core-rust/pull/4624)).
+- Save mime headers for messages not signed with a known key ([#4557](https://github.com/deltachat/deltachat-core-rust/pull/4557)).
+- Return from `dc_get_chatlist(DC_GCL_FOR_FORWARDING)` only chats where we can send ([#4616](https://github.com/deltachat/deltachat-core-rust/pull/4616)).
+- Do not allow dots at the end of email addresses.
+- deltachat-rpc-client: Remove `aiodns` optional dependency from required dependencies.
+  `aiodns` depends on `pycares` which [fails to install in Termux](https://github.com/saghul/aiodns/issues/98).
+
+## [1.120.0] - 2023-08-28
+
+### API-Changes
+
+- jsonrpc: Add `resend_messages`.
+
+### Fixes
+
+- Update async-imap to 0.9.1 to fix memory leak.
+- Delete messages from SMTP queue only on user demand ([#4579](https://github.com/deltachat/deltachat-core-rust/pull/4579)).
+- Do not send images without transparency as stickers ([#4611](https://github.com/deltachat/deltachat-core-rust/pull/4611)).
+- `prepare_msg_blob()`: do not use the image if it has Exif metadata but the image cannot be recoded.
+
+### Refactor
+
+- Hide accounts.rs constants from public API.
+- Hide pgp module from public API.
+
+### Build system
+
+- Update to Zig 0.11.0.
+- Update to Rust 1.72.0.
+
+### CI
+
+- Run on push to stable branch.
+
+### Miscellaneous Tasks
+
+- python: Fix lint errors.
+- python: Fix `ruff` 0.0.286 warnings.
+- Fix beta clippy warnings.
+
+## [1.119.1] - 2023-08-06
+
+Bugfix release attempting to fix the [iOS build error](https://github.com/deltachat/deltachat-core-rust/issues/4610).
+
+### Features / Changes
+
+- Guess message viewtype from "application/octet-stream" attachment extension ([#4378](https://github.com/deltachat/deltachat-core-rust/pull/4378)).
+
+### Fixes
+
+- Update `xattr` from 1.0.0 to 1.0.1 to fix UnsupportedPlatformError import.
+
+### Tests
+
+- webxdc: Ensure unknown WebXDC update properties do not result in an error.
+
 ## [1.119.0] - 2023-08-03
 
 ### Fixes
@@ -2712,3 +3014,15 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.116.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.115.0...v1.116.0
 [1.117.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.116.0...v1.117.0
 [1.118.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.117.0...v1.118.0
+[1.119.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.118.0...v1.119.0
+[1.119.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.119.0...v1.119.1
+[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
+[1.126.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.126.0...v1.126.1
+[1.127.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.126.1...v1.127.0

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "deltachat"
-version = "1.119.0"
+version = "1.127.0"
 edition = "2021"
 license = "MPL-2.0"
-rust-version = "1.67"
+rust-version = "1.70"
 
 [profile.dev]
 debug = 0
@@ -24,10 +24,7 @@ lto = true
 panic = 'abort'
 opt-level = "z"
 codegen-units = 1
-
-[patch.crates-io]
-quinn-udp = { git = "https://github.com/quinn-rs/quinn", branch="main" }
-quinn-proto = { git = "https://github.com/quinn-rs/quinn", branch="main" }
+strip = true
 
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
@@ -36,13 +33,13 @@ ratelimit = { path = "./deltachat-ratelimit" }
 
 anyhow = "1"
 async-channel = "1.8.0"
-async-imap = { version = "0.9.0", default-features = false, features = ["runtime-tokio"] }
+async-imap = { version = "0.9.1", default-features = false, features = ["runtime-tokio"] }
 async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
 async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
 async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
 backtrace = "0.3"
 base64 = "0.21"
-brotli = { version = "3.3", default-features=false, features = ["std"] }
+brotli = { version = "3.4", default-features=false, features = ["std"] }
 chrono = { version = "0.4", default-features=false, features = ["clock", "std"] }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch = "master" }
@@ -50,11 +47,12 @@ escaper = "0.1"
 fast-socks5 = "0.8"
 fd-lock = "3.0.11"
 futures = "0.3"
-futures-lite = "1.13.0"
+futures-lite = "2.0.0"
 hex = "0.4.0"
+hickory-resolver = "0.24"
 humansize = "2"
-image = { version = "0.24.6", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
-iroh = { version = "0.4.1", default-features = false }
+image = { version = "0.24.7", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
+iroh = { git = "https://github.com/deltachat/iroh", branch = "0.4-update-quic", default-features = false }
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"
@@ -69,13 +67,13 @@ parking_lot = "0.12"
 pgp = { version = "0.10", default-features = false }
 pretty_env_logger = { version = "0.5", optional = true }
 qrcodegen = "1.7.0"
-quick-xml = "0.30"
+quick-xml = "0.31"
 rand = "0.8"
-regex = "1.8"
-reqwest = { version = "0.11.18", features = ["json"] }
+regex = "1.9"
+reqwest = { version = "0.11.20", features = ["json"] }
 rusqlite = { version = "0.29", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
-sanitize-filename = "0.4"
+sanitize-filename = "0.5"
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10"
@@ -90,16 +88,15 @@ tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 tokio-io-timeout = "1.2.0"
 tokio-stream = { version = "0.1.14", features = ["fs"] }
 tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
-tokio-util = "0.7.8"
+tokio-util = "0.7.9"
 toml = "0.7"
-trust-dns-resolver = "0.22"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }
 
 [dev-dependencies]
 ansi_term = "0.12.0"
 criterion = { version = "0.5.1", features = ["async_tokio"] }
-futures-lite = "1.13"
+futures-lite = "2.0.0"
 log = "0.4"
 pretty_env_logger = "0.5"
 proptest = { version = "1", default-features = false, features = ["std"] }

README.md

@@ -3,8 +3,8 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/yoav-lavi/melody/actions/workflows/rust.yml">
-    <img alt="Rust CI" src="https://github.com/yoav-lavi/melody/actions/workflows/rust.yml/badge.svg">
+  <a href="https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml">
+    <img alt="Rust CI" src="https://github.com/deltachat/deltachat-core-rust/actions/workflows/ci.yml/badge.svg">
   </a>
 </p>
 

cliff.toml

@@ -54,7 +54,7 @@ header = """
 # Changelog\n
 """
 # template for the changelog body
-# https://tera.netlify.app/docs/#introduction
+# https://keats.github.io/tera/docs/#templates
 body = """
 {% if version %}\
     ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}

deltachat-ffi/Cargo.toml

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

deltachat-ffi/deltachat.h

@@ -301,6 +301,19 @@ dc_context_t*   dc_context_new_closed        (const char* dbfile);
 int             dc_context_open              (dc_context_t *context, const char* passphrase);
 
 
+/**
+ * Changes the passphrase on the open database.
+ * Existing database must already be encrypted and the passphrase cannot be NULL or empty.
+ * It is impossible to encrypt unencrypted database with this method and vice versa.
+ *
+ * @memberof dc_context_t
+ * @param context The context object.
+ * @param passphrase The new passphrase.
+ * @return 1 on success, 0 on error.
+ */
+int             dc_context_change_passphrase (dc_context_t* context, const char* passphrase);
+
+
 /**
  * Returns 1 if database is open.
  *
@@ -371,7 +384,12 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 /**
  * Configure the context. The configuration is handled by key=value pairs as:
  *
- * - `addr`         = address to display (always needed)
+ * - `addr`         = Email address to use for configuration.
+ *                    If dc_configure() fails this is not the email address actually in use.
+ *                    Use `configured_addr` to find out the email address actually in use.
+ * - `configured_addr` = Email address actually in use.
+ *                    Unless for testing, do not set this value using dc_set_config().
+ *                    Instead, set `addr` and call dc_configure().
  * - `mail_server`  = IMAP-server, guessed if left out
  * - `mail_user`    = IMAP-username, guessed if left out
  * - `mail_pw`      = IMAP-password (always needed)
@@ -430,7 +448,9 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    DC_KEY_GEN_RSA2048 (1)=
  *                    generate RSA 2048 keypair
  *                    DC_KEY_GEN_ED25519 (2)=
- *                    generate Ed25519 keypair
+ *                    generate Curve25519 keypair
+ *                    DC_KEY_GEN_RSA4096 (3)=
+ *                    generate RSA 4096 keypair
  * - `save_mime_headers` = 1=save mime headers
  *                    and make dc_get_mime_headers() work for subsequent calls,
  *                    0=do not save mime headers (default)
@@ -477,6 +497,9 @@ 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.
@@ -485,6 +508,9 @@ 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.
  * - `verified_one_on_one_chats` = Feature flag for verified 1:1 chats; the UI should set it
  *                    to 1 if it supports verified 1:1 chats.
  *                    Regardless of this setting, `dc_chat_is_protected()` returns true while the key is verified,
@@ -816,7 +842,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 ASCII armored public key.
+ * @param public_data Ignored, actual public key is extracted from secret_data.
  * @param secret_data ASCII armored secret key.
  * @return 1 on success, 0 on failure.
  */
@@ -870,7 +896,8 @@ 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.
+ *     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.
  * @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.
@@ -1328,6 +1355,20 @@ int             dc_get_msg_cnt               (dc_context_t* context, uint32_t ch
 int             dc_get_fresh_msg_cnt         (dc_context_t* context, uint32_t chat_id);
 
 
+/**
+ * Returns a list of similar chats.
+ *
+ * @warning This is an experimental API which may change or be removed in the future.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as returned from dc_context_new().
+ * @param chat_id The ID of the chat for which to find similar chats.
+ * @return The list of similar chats.
+ *     On errors, NULL is returned.
+ *     Must be freed using dc_chatlist_unref() when no longer used.
+ */
+dc_chatlist_t*     dc_get_similar_chatlist   (dc_context_t* context, uint32_t chat_id);
+
 
 /**
  * Estimate the number of messages that will be deleted
@@ -1459,6 +1500,7 @@ 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.
@@ -1670,24 +1712,12 @@ 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 normal one-to-one chats
- * and will not be aware of other members.
+ * however, recipients get the messages in a read-only chat
+ * and will see who the other members are.
  *
- * 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.
+ * 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.
  *
  * @memberof dc_context_t
  * @param context The context object.
@@ -2230,8 +2260,7 @@ 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 typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
- *   the format is `delta-chat-<day>-<number>.tar`
+ *   The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.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
@@ -2244,6 +2273,7 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
  *
  * - **DC_IMEX_IMPORT_SELF_KEYS** (2) - Import private keys found in the directory given as `param1`.
  *   The last imported key is made the default keys unless its name contains the string `legacy`. Public keys are not imported.
+ *   If `param1` is a filename, import the private key from the file and make it the default.
  *
  * While dc_imex() returns immediately, the started job may take a while,
  * you can stop it using dc_stop_ongoing_process(). During execution of the job,
@@ -3936,7 +3966,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 reveived time, the sending time or another time.
+ * This may be the received 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().
@@ -5033,6 +5063,7 @@ 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);
 
@@ -5045,7 +5076,7 @@ char*           dc_contact_get_verifier_addr       (dc_contact_t* contact);
  * @memberof dc_contact_t
  * @param contact The contact object.
  * @return 
- *    The `ContactId` of the verifiers address. If it is the same address as the contact itself,
+ *    The contact ID of the verifier. If it is DC_CONTACT_ID_SELF,
  *    we verified the contact ourself. If it is 0, we don't have verifier information or 
  *    the contact is not verified.
  */
@@ -5741,12 +5772,11 @@ 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 method JSON-RPC method name, e.g. `check_email_validity`.
- * @param params JSON-RPC method parameters, e.g. `["alice@example.org"]`.
+ * @param input JSON-RPC request.
  * @return JSON-RPC response as string, must be freed using dc_str_unref() after usage.
- *     On error, NULL is returned.
+ *     If there is no response, NULL is returned.
  */
-char* dc_jsonrpc_blocking_call(dc_jsonrpc_instance_t* jsonrpc_instance, const char *method, const char *params);
+char* dc_jsonrpc_blocking_call(dc_jsonrpc_instance_t* jsonrpc_instance, const char *input);
 
 /**
  * @class dc_event_emitter_t
@@ -6282,6 +6312,7 @@ void dc_event_unref(dc_event_t* event);
 #define DC_KEY_GEN_DEFAULT 0
 #define DC_KEY_GEN_RSA2048 1
 #define DC_KEY_GEN_ED25519 2
+#define DC_KEY_GEN_RSA4096 3
 
 
 /**

deltachat-ffi/src/lib.rs

@@ -167,6 +167,24 @@ pub unsafe extern "C" fn dc_context_open(
         .unwrap_or(0)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_context_change_passphrase(
+    context: *mut dc_context_t,
+    passphrase: *const libc::c_char,
+) -> libc::c_int {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_context_change_passphrase()");
+        return 0;
+    }
+
+    let ctx = &*context;
+    let passphrase = to_string_lossy(passphrase);
+    block_on(ctx.change_passphrase(passphrase))
+        .context("dc_context_change_passphrase() failed")
+        .log_err(ctx)
+        .is_ok() as libc::c_int
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_context_is_open(context: *mut dc_context_t) -> libc::c_int {
     if context.is_null() {
@@ -787,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() {
@@ -796,9 +814,8 @@ pub unsafe extern "C" fn dc_preconfigure_keypair(
     }
     let ctx = &*context;
     let addr = to_string_lossy(addr);
-    let public_data = to_string_lossy(public_data);
     let secret_data = to_string_lossy(secret_data);
-    block_on(preconfigure_keypair(ctx, &addr, &public_data, &secret_data))
+    block_on(preconfigure_keypair(ctx, &addr, &secret_data))
         .context("Failed to save keypair")
         .log_err(ctx)
         .is_ok() as libc::c_int
@@ -1234,6 +1251,30 @@ pub unsafe extern "C" fn dc_get_fresh_msg_cnt(
     })
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_get_similar_chatlist(
+    context: *mut dc_context_t,
+    chat_id: u32,
+) -> *mut dc_chatlist_t {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_get_similar_chatlist()");
+        return ptr::null_mut();
+    }
+    let ctx = &*context;
+
+    let chat_id = ChatId::new(chat_id);
+    match block_on(chat_id.get_similar_chatlist(ctx))
+        .context("failed to get similar chatlist")
+        .log_err(ctx)
+    {
+        Ok(list) => {
+            let ffi_list = ChatlistWrapper { context, list };
+            Box::into_raw(Box::new(ffi_list))
+        }
+        Err(_) => ptr::null_mut(),
+    }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_estimate_deletion_cnt(
     context: *mut dc_context_t,
@@ -1381,6 +1422,7 @@ 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,
@@ -2491,7 +2533,12 @@ pub unsafe extern "C" fn dc_set_location(
     }
     let ctx = &*context;
 
-    block_on(location::set(ctx, latitude, longitude, accuracy)) as _
+    block_on(async move {
+        location::set(ctx, latitude, longitude, accuracy)
+            .await
+            .log_err(ctx)
+            .unwrap_or_default()
+    }) as libc::c_int
 }
 
 #[no_mangle]
@@ -4465,7 +4512,14 @@ pub unsafe extern "C" fn dc_provider_new_from_email(
 
     let ctx = &*context;
 
-    match block_on(provider::get_provider_info(ctx, addr.as_str(), true)) {
+    match block_on(provider::get_provider_info_by_addr(
+        ctx,
+        addr.as_str(),
+        true,
+    ))
+    .log_err(ctx)
+    .unwrap_or_default()
+    {
         Some(provider) => provider,
         None => ptr::null_mut(),
     }
@@ -4492,11 +4546,14 @@ 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(
+            match block_on(provider::get_provider_info_by_addr(
                 ctx,
                 addr.as_str(),
                 socks5_enabled,
-            )) {
+            ))
+            .log_err(ctx)
+            .unwrap_or_default()
+            {
                 Some(provider) => provider,
                 None => ptr::null_mut(),
             }
@@ -4944,7 +5001,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, RpcServer, RpcSession};
+    use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcSession};
 
     use super::*;
 
@@ -5020,25 +5077,24 @@ mod jsonrpc {
     #[no_mangle]
     pub unsafe extern "C" fn dc_jsonrpc_blocking_call(
         jsonrpc_instance: *mut dc_jsonrpc_instance_t,
-        method: *const libc::c_char,
-        params: *const libc::c_char,
+        input: *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 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));
+        let input = to_string_lossy(input);
+        let res = block_on(api.handle.process_incoming(&input));
         match res {
-            Ok(res) => res.to_string().strdup(),
-            Err(_) => ptr::null_mut(),
+            Some(message) => {
+                if let Ok(message) = serde_json::to_string(&message) {
+                    message.strdup()
+                } else {
+                    ptr::null_mut()
+                }
+            }
+            None => ptr::null_mut(),
         }
     }
 }

deltachat-jsonrpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.119.0"
+version = "1.127.0"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
@@ -15,26 +15,26 @@ required-features = ["webserver"]
 anyhow = "1"
 deltachat = { path = ".." }
 num-traits = "0.2"
-schemars = "0.8.11"
+schemars = "0.8.13"
 serde = { version = "1.0", features = ["derive"] }
-tempfile = "3.6.0"
+tempfile = "3.8.0"
 log = "0.4"
 async-channel = { version = "1.8.0" }
 futures = { version = "0.3.28" }
-serde_json = "1.0.99"
+serde_json = "1.0.105"
 yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }
-typescript-type-def = { version = "0.5.5", features = ["json_value"] }
-tokio = { version = "1.29.1" }
-sanitize-filename = "0.4"
+typescript-type-def = { version = "0.5.8", features = ["json_value"] }
+tokio = { version = "1.33.0" }
+sanitize-filename = "0.5"
 walkdir = "2.3.3"
 base64 = "0.21"
 
 # optional dependencies
-axum = { version = "0.6.18", optional = true, features = ["ws"] }
+axum = { version = "0.6.20", optional = true, features = ["ws"] }
 env_logger = { version = "0.10.0", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.29.1", features = ["full", "rt-multi-thread"] }
+tokio = { version = "1.33.0", features = ["full", "rt-multi-thread"] }
 
 
 [features]

deltachat-jsonrpc/src/api/mod.rs

@@ -569,6 +569,21 @@ impl CommandApi {
         Ok(l)
     }
 
+    /// Returns chats similar to the given one.
+    ///
+    /// Experimental API, subject to change without notice.
+    async fn get_similar_chat_ids(&self, account_id: u32, chat_id: u32) -> Result<Vec<u32>> {
+        let ctx = self.get_context(account_id).await?;
+        let chat_id = ChatId::new(chat_id);
+        let list = chat_id
+            .get_similar_chat_ids(&ctx)
+            .await?
+            .into_iter()
+            .map(|(chat_id, _metric)| chat_id.to_u32())
+            .collect();
+        Ok(list)
+    }
+
     async fn get_chatlist_items_by_entries(
         &self,
         account_id: u32,
@@ -800,24 +815,12 @@ impl CommandApi {
     /// Create a new broadcast list.
     ///
     /// Broadcast lists are similar to groups on the sending device,
-    /// however, recipients get the messages in normal one-to-one chats
-    /// and will not be aware of other members.
+    /// however, recipients get the messages in a read-only chat
+    /// and will see who the other members are.
     ///
-    /// 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.
+    /// 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.
     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,6 +1418,10 @@ 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,
@@ -1737,6 +1744,9 @@ impl CommandApi {
         let mut msg = Message::new(Viewtype::Sticker);
         msg.set_file(&sticker_path, None);
 
+        // JSON-rpc does not need heuristics to turn [Viewtype::Sticker] into [Viewtype::Image]
+        msg.force_sticker();
+
         let message_id = deltachat::chat::send_msg(&ctx, ChatId::new(chat_id), &mut msg).await?;
         Ok(message_id.to_u32())
     }
@@ -2049,6 +2059,23 @@ 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/src/api/types/chat_list.rs

@@ -8,15 +8,12 @@ use deltachat::{
     chatlist::Chatlist,
 };
 use num_traits::cast::ToPrimitive;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use typescript_type_def::TypeDef;
 
 use super::color_int_to_hex_string;
 use super::message::MessageViewtype;
 
-#[derive(Deserialize, Serialize, TypeDef, schemars::JsonSchema)]
-pub struct ChatListEntry(pub u32, pub u32);
-
 #[derive(Serialize, TypeDef, schemars::JsonSchema)]
 #[serde(tag = "kind")]
 pub enum ChatListItemFetchResult {

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

@@ -318,6 +318,7 @@ pub enum DownloadState {
     Done,
     Available,
     Failure,
+    Undecipherable,
     InProgress,
 }
 
@@ -327,6 +328,7 @@ impl From<download::DownloadState> for DownloadState {
             download::DownloadState::Done => DownloadState::Done,
             download::DownloadState::Available => DownloadState::Available,
             download::DownloadState::Failure => DownloadState::Failure,
+            download::DownloadState::Undecipherable => DownloadState::Undecipherable,
             download::DownloadState::InProgress => DownloadState::InProgress,
         }
     }

deltachat-jsonrpc/typescript/package.json

@@ -55,5 +55,5 @@
   },
   "type": "module",
   "types": "dist/deltachat.d.ts",
-  "version": "1.119.0"
+  "version": "1.127.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 arives at A and if it is encrypted
+    // Check if answer arrives 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.119.0"
+version = "1.127.0"
 license = "MPL-2.0"
 edition = "2021"
 
@@ -9,7 +9,7 @@ ansi_term = "0.12.1"
 anyhow = "1"
 deltachat = { path = "..", features = ["internals"]}
 dirs = "5"
-log = "0.4.19"
+log = "0.4.20"
 pretty_env_logger = "0.5"
 rusqlite = "0.29"
 rustyline = "12"

deltachat-repl/src/cmdline.rs

@@ -139,11 +139,7 @@ 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 dir.is_err() {
-            error!(context, "Import: Cannot open directory \"{}\".", &real_spec,);
-            return false;
-        } else {
-            let mut dir = dir.unwrap();
+        if let Ok(mut dir) = dir {
             while let Ok(Some(entry)) = dir.next_entry().await {
                 let name_f = entry.file_name();
                 let name = name_f.to_string_lossy();
@@ -155,6 +151,9 @@ 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);
@@ -188,6 +187,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
         DownloadState::Available => " [⬇ Download available]",
         DownloadState::InProgress => " [⬇ Download in progress...]️",
         DownloadState::Failure => " [⬇ Download failed]",
+        DownloadState::Undecipherable => " [⬇ Decryption failed]",
     };
 
     let temp2 = timestamp_to_str(msg.get_timestamp());
@@ -814,15 +814,30 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         }
         "chatinfo" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
+            let sel_chat_id = sel_chat.as_ref().unwrap().get_id();
 
-            let contacts =
-                chat::get_chat_contacts(&context, sel_chat.as_ref().unwrap().get_id()).await?;
+            let contacts = chat::get_chat_contacts(&context, sel_chat_id).await?;
             println!("Memberlist:");
 
             log_contactlist(&context, &contacts).await?;
+            println!("{} contacts", contacts.len());
+
+            let similar_chats = sel_chat_id.get_similar_chat_ids(&context).await?;
+            if !similar_chats.is_empty() {
+                println!("Similar chats: ");
+                for (similar_chat_id, metric) in similar_chats {
+                    let similar_chat = Chat::load_from_db(&context, similar_chat_id).await?;
+                    println!(
+                        "{} (#{}) {:.1}",
+                        similar_chat.name,
+                        similar_chat_id,
+                        100.0 * metric
+                    );
+                }
+            }
+
             println!(
-                "{} contacts\nLocation streaming: {}",
-                contacts.len(),
+                "Location streaming: {}",
                 location::is_sending_locations_to_chat(
                     &context,
                     Some(sel_chat.as_ref().unwrap().get_id())
@@ -887,7 +902,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,19 +37,14 @@ $ tox --devenv env
 $ . env/bin/activate
 ```
 
-It is recommended to use IPython, because it supports using `await` directly
-from the REPL.
-
 ```
-$ 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()
+$ 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()
 ```

deltachat-rpc-client/examples/echobot.py

@@ -4,23 +4,21 @@
 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)
-async def log_event(event):
+def log_event(event):
     print(event)
 
 
 @hooks.on(events.NewMessage)
-async def echo(event):
+def echo(event):
     snapshot = event.message_snapshot
-    await snapshot.chat.send_text(snapshot.text)
+    snapshot.chat.send_text(snapshot.text)
 
 
 if __name__ == "__main__":
-    asyncio.run(run_bot_cli(hooks))
+    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)
-async def log_event(event):
+def log_event(event):
     if event.kind == EventType.INFO:
         logging.info(event.msg)
     elif event.kind == EventType.WARNING:
@@ -21,54 +21,54 @@ async def log_event(event):
 
 
 @hooks.on(events.RawEvent(EventType.ERROR))
-async def log_error(event):
+def log_error(event):
     logging.error(event.msg)
 
 
 @hooks.on(events.MemberListChanged)
-async def on_memberlist_changed(event):
+def on_memberlist_changed(event):
     logging.info("member %s was %s", event.member, "added" if event.member_added else "removed")
 
 
 @hooks.on(events.GroupImageChanged)
-async def on_group_image_changed(event):
+def on_group_image_changed(event):
     logging.info("group image %s", "deleted" if event.image_deleted else "changed")
 
 
 @hooks.on(events.GroupNameChanged)
-async def on_group_name_changed(event):
+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))
-async def echo(event):
+def echo(event):
     snapshot = event.message_snapshot
     if snapshot.text or snapshot.file:
-        await snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
+        snapshot.chat.send_message(text=snapshot.text, file=snapshot.file)
 
 
 @hooks.on(events.NewMessage(command="/help"))
-async def help_command(event):
+def help_command(event):
     snapshot = event.message_snapshot
-    await snapshot.chat.send_text("Send me any message and I will echo it back")
+    snapshot.chat.send_text("Send me any message and I will echo it back")
 
 
-async def main():
-    async with Rpc() as rpc:
+def main():
+    with Rpc() as rpc:
         deltachat = DeltaChat(rpc)
-        system_info = await deltachat.get_system_info()
+        system_info = deltachat.get_system_info()
         logging.info("Running deltachat core %s", system_info.deltachat_core_version)
 
-        accounts = await deltachat.get_all_accounts()
-        account = accounts[0] if accounts else await deltachat.add_account()
+        accounts = deltachat.get_all_accounts()
+        account = accounts[0] if accounts else deltachat.add_account()
 
         bot = Bot(account, hooks)
-        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 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 __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
+    main()

deltachat-rpc-client/examples/echobot_no_hooks.py

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

deltachat-rpc-client/pyproject.toml

@@ -5,13 +5,8 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "deltachat-rpc-client"
 description = "Python client for Delta Chat core JSON-RPC interface"
-dependencies = [
-    "aiohttp",
-    "aiodns"
-]
 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",
@@ -76,3 +71,6 @@ 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 asynchronous high-level API"""
+"""Delta Chat JSON-RPC 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)
 
 
-async def run_client_cli(
+def run_client_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -54,10 +54,10 @@ async def run_client_cli(
     """
     from .client import Client
 
-    await _run_cli(Client, hooks, argv, **kwargs)
+    _run_cli(Client, hooks, argv, **kwargs)
 
 
-async def run_bot_cli(
+def run_bot_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
     **kwargs,
@@ -68,10 +68,10 @@ async def run_bot_cli(
     """
     from .client import Bot
 
-    await _run_cli(Bot, hooks, argv, **kwargs)
+    _run_cli(Bot, hooks, argv, **kwargs)
 
 
-async def _run_cli(
+def _run_cli(
     client_type: Type["Client"],
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
@@ -93,20 +93,20 @@ async def _run_cli(
     parser.add_argument("--password", action="store", help="password")
     args = parser.parse_args(argv[1:])
 
-    async with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
+    with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
         deltachat = DeltaChat(rpc)
-        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()
+        core_version = (deltachat.get_system_info()).deltachat_core_version
+        accounts = deltachat.get_all_accounts()
+        account = accounts[0] if accounts else deltachat.add_account()
 
         client = client_type(account, hooks)
         client.logger.debug("Running deltachat core %s", core_version)
-        if not await client.is_configured():
+        if not 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"
-            # 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()
+            configure_thread = Thread(run=client.configure, kwargs={"email": args.email, "password": args.password})
+            configure_thread.start()
+        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
 
-    async def wait_for_event(self) -> AttrDict:
+    def wait_for_event(self) -> AttrDict:
         """Wait until the next event and return it."""
-        return AttrDict(await self._rpc.wait_for_event(self.id))
+        return AttrDict(self._rpc.wait_for_event(self.id))
 
-    async def remove(self) -> None:
+    def remove(self) -> None:
         """Remove the account."""
-        await self._rpc.remove_account(self.id)
+        self._rpc.remove_account(self.id)
 
-    async def start_io(self) -> None:
+    def start_io(self) -> None:
         """Start the account I/O."""
-        await self._rpc.start_io(self.id)
+        self._rpc.start_io(self.id)
 
-    async def stop_io(self) -> None:
+    def stop_io(self) -> None:
         """Stop the account I/O."""
-        await self._rpc.stop_io(self.id)
+        self._rpc.stop_io(self.id)
 
-    async def get_info(self) -> AttrDict:
+    def get_info(self) -> AttrDict:
         """Return dictionary of this account configuration parameters."""
-        return AttrDict(await self._rpc.get_info(self.id))
+        return AttrDict(self._rpc.get_info(self.id))
 
-    async def get_size(self) -> int:
+    def get_size(self) -> int:
         """Get the combined filesize of an account in bytes."""
-        return await self._rpc.get_account_file_size(self.id)
+        return self._rpc.get_account_file_size(self.id)
 
-    async def is_configured(self) -> bool:
+    def is_configured(self) -> bool:
         """Return True if this account is configured."""
-        return await self._rpc.is_configured(self.id)
+        return self._rpc.is_configured(self.id)
 
-    async def set_config(self, key: str, value: Optional[str] = None) -> None:
+    def set_config(self, key: str, value: Optional[str] = None) -> None:
         """Set configuration value."""
-        await self._rpc.set_config(self.id, key, value)
+        self._rpc.set_config(self.id, key, value)
 
-    async def get_config(self, key: str) -> Optional[str]:
+    def get_config(self, key: str) -> Optional[str]:
         """Get configuration value."""
-        return await self._rpc.get_config(self.id, key)
+        return self._rpc.get_config(self.id, key)
 
-    async def update_config(self, **kwargs) -> None:
+    def update_config(self, **kwargs) -> None:
         """update config values."""
         for key, value in kwargs.items():
-            await self.set_config(key, value)
+            self.set_config(key, value)
 
-    async def set_avatar(self, img_path: Optional[str] = None) -> None:
+    def set_avatar(self, img_path: Optional[str] = None) -> None:
         """Set self avatar.
 
         Passing None will discard the currently set avatar.
         """
-        await self.set_config("selfavatar", img_path)
+        self.set_config("selfavatar", img_path)
 
-    async def get_avatar(self) -> Optional[str]:
+    def get_avatar(self) -> Optional[str]:
         """Get self avatar."""
-        return await self.get_config("selfavatar")
+        return self.get_config("selfavatar")
 
-    async def configure(self) -> None:
+    def configure(self) -> None:
         """Configure an account."""
-        await self._rpc.configure(self.id)
+        self._rpc.configure(self.id)
 
-    async def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
+    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 = (await obj.get_snapshot()).address
-        return Contact(self, await self._rpc.create_contact(self.id, obj, name))
+            obj = obj.get_snapshot().address
+        return Contact(self, 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)
 
-    async def get_contact_by_addr(self, address: str) -> Optional[Contact]:
+    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 = await self._rpc.lookup_contact_id_by_addr(self.id, address)
+        contact_id = self._rpc.lookup_contact_id_by_addr(self.id, address)
         return contact_id and Contact(self, contact_id)
 
-    async def get_blocked_contacts(self) -> List[AttrDict]:
+    def get_blocked_contacts(self) -> List[AttrDict]:
         """Return a list with snapshots of all blocked contacts."""
-        contacts = await self._rpc.get_blocked_contacts(self.id)
+        contacts = self._rpc.get_blocked_contacts(self.id)
         return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
 
-    async def get_contacts(
+    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 = await self._rpc.get_contacts(self.id, flags, query)
+            contacts = self._rpc.get_contacts(self.id, flags, query)
             return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
-        contacts = await self._rpc.get_contact_ids(self.id, flags, query)
+        contacts = 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)
 
-    async def get_chatlist(
+    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 = await self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
+        entries = 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 = await self._rpc.get_chatlist_items_by_entries(self.id, entries)
+        items = 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
 
-    async def create_group(self, name: str, protect: bool = False) -> Chat:
+    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, await self._rpc.create_group_chat(self.id, name, protect))
+        return Chat(self, 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)
 
-    async def secure_join(self, qrdata: str) -> Chat:
+    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, await self._rpc.secure_join(self.id, qrdata))
+        return Chat(self, self._rpc.secure_join(self.id, qrdata))
 
-    async def get_qr_code(self) -> Tuple[str, str]:
+    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 await self._rpc.get_chat_securejoin_qr_code_svg(self.id, None)
+        return 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)
 
-    async def mark_seen_messages(self, messages: List[Message]) -> None:
+    def mark_seen_messages(self, messages: List[Message]) -> None:
         """Mark the given set of messages as seen."""
-        await self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
+        self._rpc.markseen_msgs(self.id, [msg.id for msg in messages])
 
-    async def delete_messages(self, messages: List[Message]) -> None:
+    def delete_messages(self, messages: List[Message]) -> None:
         """Delete messages (local and remote)."""
-        await self._rpc.delete_messages(self.id, [msg.id for msg in messages])
+        self._rpc.delete_messages(self.id, [msg.id for msg in messages])
 
-    async def get_fresh_messages(self) -> List[Message]:
+    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 = await self._rpc.get_fresh_msgs(self.id)
+        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
 
-    async def get_next_messages(self) -> List[Message]:
+    def get_next_messages(self) -> List[Message]:
         """Return a list of next messages."""
-        next_msg_ids = await self._rpc.get_next_msgs(self.id)
+        next_msg_ids = self._rpc.get_next_msgs(self.id)
         return [Message(self, msg_id) for msg_id in next_msg_ids]
 
-    async def wait_next_messages(self) -> List[Message]:
+    def wait_next_messages(self) -> List[Message]:
         """Wait for new messages and return a list of them."""
-        next_msg_ids = await self._rpc.wait_next_msgs(self.id)
+        next_msg_ids = self._rpc.wait_next_msgs(self.id)
         return [Message(self, msg_id) for msg_id in next_msg_ids]
 
-    async def get_fresh_messages_in_arrival_order(self) -> List[Message]:
+    def get_fresh_messages_in_arrival_order(self) -> List[Message]:
         """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
         warn(
             "get_fresh_messages_in_arrival_order is deprecated, use get_next_messages instead.",
             DeprecationWarning,
             stacklevel=2,
         )
-        fresh_msg_ids = sorted(await self._rpc.get_fresh_msgs(self.id))
+        fresh_msg_ids = sorted(self._rpc.get_fresh_msgs(self.id))
         return [Message(self, msg_id) for msg_id in fresh_msg_ids]
 
-    async def export_backup(self, path, passphrase: str = "") -> None:
+    def export_backup(self, path, passphrase: str = "") -> None:
         """Export backup."""
-        await self._rpc.export_backup(self.id, str(path), passphrase)
+        self._rpc.export_backup(self.id, str(path), passphrase)
 
-    async def import_backup(self, path, passphrase: str = "") -> None:
+    def import_backup(self, path, passphrase: str = "") -> None:
         """Import backup."""
-        await self._rpc.import_backup(self.id, str(path), passphrase)
+        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
 
-    async def delete(self) -> None:
+    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
         """
-        await self._rpc.delete_chat(self.account.id, self.id)
+        self._rpc.delete_chat(self.account.id, self.id)
 
-    async def block(self) -> None:
+    def block(self) -> None:
         """Block this chat."""
-        await self._rpc.block_chat(self.account.id, self.id)
+        self._rpc.block_chat(self.account.id, self.id)
 
-    async def accept(self) -> None:
+    def accept(self) -> None:
         """Accept this contact request chat."""
-        await self._rpc.accept_chat(self.account.id, self.id)
+        self._rpc.accept_chat(self.account.id, self.id)
 
-    async def leave(self) -> None:
+    def leave(self) -> None:
         """Leave this chat."""
-        await self._rpc.leave_group(self.account.id, self.id)
+        self._rpc.leave_group(self.account.id, self.id)
 
-    async def mute(self, duration: Optional[int] = None) -> None:
+    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: dict = {"kind": "Until", "duration": duration}
         else:
             dur = {"kind": "Forever"}
-        await self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
+        self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
 
-    async def unmute(self) -> None:
+    def unmute(self) -> None:
         """Unmute this chat."""
-        await self._rpc.set_chat_mute_duration(self.account.id, self.id, {"kind": "NotMuted"})
+        self._rpc.set_chat_mute_duration(self.account.id, self.id, {"kind": "NotMuted"})
 
-    async def pin(self) -> None:
+    def pin(self) -> None:
         """Pin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
 
-    async def unpin(self) -> None:
+    def unpin(self) -> None:
         """Unpin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
 
-    async def archive(self) -> None:
+    def archive(self) -> None:
         """Archive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
 
-    async def unarchive(self) -> None:
+    def unarchive(self) -> None:
         """Unarchive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
 
-    async def set_name(self, name: str) -> None:
+    def set_name(self, name: str) -> None:
         """Set name of this chat."""
-        await self._rpc.set_chat_name(self.account.id, self.id, name)
+        self._rpc.set_chat_name(self.account.id, self.id, name)
 
-    async def set_ephemeral_timer(self, timer: int) -> None:
+    def set_ephemeral_timer(self, timer: int) -> None:
         """Set ephemeral timer of this chat."""
-        await self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
+        self._rpc.set_chat_ephemeral_timer(self.account.id, self.id, timer)
 
-    async def get_encryption_info(self) -> str:
+    def get_encryption_info(self) -> str:
         """Return encryption info for this chat."""
-        return await self._rpc.get_chat_encryption_info(self.account.id, self.id)
+        return self._rpc.get_chat_encryption_info(self.account.id, self.id)
 
-    async def get_qr_code(self) -> Tuple[str, str]:
+    def get_qr_code(self) -> Tuple[str, str]:
         """Get Join-Group QR code text and SVG data."""
-        return await self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
+        return self._rpc.get_chat_securejoin_qr_code_svg(self.account.id, self.id)
 
-    async def get_basic_snapshot(self) -> AttrDict:
+    def get_basic_snapshot(self) -> AttrDict:
         """Get a chat snapshot with basic info about this chat."""
-        info = await self._rpc.get_basic_chat_info(self.account.id, self.id)
+        info = self._rpc.get_basic_chat_info(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    async def get_full_snapshot(self) -> AttrDict:
+    def get_full_snapshot(self) -> AttrDict:
         """Get a full snapshot of this chat."""
-        info = await self._rpc.get_full_chat_by_id(self.account.id, self.id)
+        info = self._rpc.get_full_chat_by_id(self.account.id, self.id)
         return AttrDict(chat=self, **info)
 
-    async def can_send(self) -> bool:
+    def can_send(self) -> bool:
         """Return true if messages can be sent to the chat."""
-        return await self._rpc.can_send(self.account.id, self.id)
+        return self._rpc.can_send(self.account.id, self.id)
 
-    async def send_message(
+    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 = await self._rpc.send_msg(self.account.id, self.id, draft)
+        msg_id = self._rpc.send_msg(self.account.id, self.id, draft)
         return Message(self.account, msg_id)
 
-    async def send_text(self, text: str) -> Message:
+    def send_text(self, text: str) -> Message:
         """Send a text message and return the resulting Message instance."""
-        msg_id = await self._rpc.misc_send_text_message(self.account.id, self.id, text)
+        msg_id = self._rpc.misc_send_text_message(self.account.id, self.id, text)
         return Message(self.account, msg_id)
 
-    async def send_videochat_invitation(self) -> Message:
+    def send_videochat_invitation(self) -> Message:
         """Send a videochat invitation and return the resulting Message instance."""
-        msg_id = await self._rpc.send_videochat_invitation(self.account.id, self.id)
+        msg_id = self._rpc.send_videochat_invitation(self.account.id, self.id)
         return Message(self.account, msg_id)
 
-    async def send_sticker(self, path: str) -> Message:
+    def send_sticker(self, path: str) -> Message:
         """Send an sticker and return the resulting Message instance."""
-        msg_id = await self._rpc.send_sticker(self.account.id, self.id, path)
+        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
         return Message(self.account, msg_id)
 
-    async def forward_messages(self, messages: List[Message]) -> None:
+    def forward_messages(self, messages: List[Message]) -> None:
         """Forward a list of messages to this chat."""
         msg_ids = [msg.id for msg in messages]
-        await self._rpc.forward_messages(self.account.id, msg_ids, self.id)
+        self._rpc.forward_messages(self.account.id, msg_ids, self.id)
 
-    async def set_draft(
+    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
-        await self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg)
+        self._rpc.misc_set_draft(self.account.id, self.id, text, file, quoted_msg)
 
-    async def remove_draft(self) -> None:
+    def remove_draft(self) -> None:
         """Remove draft message."""
-        await self._rpc.remove_draft(self.account.id, self.id)
+        self._rpc.remove_draft(self.account.id, self.id)
 
-    async def get_draft(self) -> Optional[AttrDict]:
+    def get_draft(self) -> Optional[AttrDict]:
         """Get draft message."""
-        snapshot = await self._rpc.get_draft(self.account.id, self.id)
+        snapshot = 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
 
-    async def get_messages(self, info_only: bool = False, add_daymarker: bool = False) -> List[Message]:
+    def get_messages(self, info_only: bool = False, add_daymarker: bool = False) -> List[Message]:
         """get the list of messages in this chat."""
-        msgs = await self._rpc.get_message_ids(self.account.id, self.id, info_only, add_daymarker)
+        msgs = 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]
 
-    async def get_fresh_message_count(self) -> int:
+    def get_fresh_message_count(self) -> int:
         """Get number of fresh messages in this chat"""
-        return await self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
+        return self._rpc.get_fresh_msg_cnt(self.account.id, self.id)
 
-    async def mark_noticed(self) -> None:
+    def mark_noticed(self) -> None:
         """Mark all messages in this chat as noticed."""
-        await self._rpc.marknoticed_chat(self.account.id, self.id)
+        self._rpc.marknoticed_chat(self.account.id, self.id)
 
-    async def add_contact(self, *contact: Union[int, str, Contact]) -> None:
+    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 = (await self.account.create_contact(cnt)).id
+                contact_id = self.account.create_contact(cnt).id
             elif not isinstance(cnt, int):
                 contact_id = cnt.id
             else:
                 contact_id = cnt
-            await self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)
+            self._rpc.add_contact_to_chat(self.account.id, self.id, contact_id)
 
-    async def remove_contact(self, *contact: Union[int, str, Contact]) -> None:
+    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 = (await self.account.create_contact(cnt)).id
+                contact_id = self.account.create_contact(cnt).id
             elif not isinstance(cnt, int):
                 contact_id = cnt.id
             else:
                 contact_id = cnt
-            await self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)
+            self._rpc.remove_contact_from_chat(self.account.id, self.id, contact_id)
 
-    async def get_contacts(self) -> List[Contact]:
+    def get_contacts(self) -> List[Contact]:
         """Get the contacts belonging to this chat.
 
         For single/direct chats self-address is not included.
         """
-        contacts = await self._rpc.get_chat_contacts(self.account.id, self.id)
+        contacts = self._rpc.get_chat_contacts(self.account.id, self.id)
         return [Contact(self.account, contact_id) for contact_id in contacts]
 
-    async def set_image(self, path: str) -> None:
+    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.
         """
-        await self._rpc.set_chat_profile_image(self.account.id, self.id, path)
+        self._rpc.set_chat_profile_image(self.account.id, self.id, path)
 
-    async def remove_image(self) -> None:
+    def remove_image(self) -> None:
         """Remove profile image of this chat."""
-        await self._rpc.set_chat_profile_image(self.account.id, self.id, None)
+        self._rpc.set_chat_profile_image(self.account.id, self.id, None)
 
-    async def get_locations(
+    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 = await self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
+        result = 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,10 +1,8 @@
 """Event loop implementations offering high level event handling/hooking."""
-import inspect
 import logging
 from typing import (
     TYPE_CHECKING,
     Callable,
-    Coroutine,
     Dict,
     Iterable,
     Optional,
@@ -78,22 +76,22 @@ class Client:
         )
         self._hooks.get(type(event), set()).remove((hook, event))
 
-    async def is_configured(self) -> bool:
-        return await self.account.is_configured()
+    def is_configured(self) -> bool:
+        return self.account.is_configured()
 
-    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)
+    def configure(self, email: str, password: str, **kwargs) -> None:
+        self.account.set_config("addr", email)
+        self.account.set_config("mail_pw", password)
         for key, value in kwargs.items():
-            await self.account.set_config(key, value)
-        await self.account.configure()
+            self.account.set_config(key, value)
+        self.account.configure()
         self.logger.debug("Account configured")
 
-    async def run_forever(self) -> None:
+    def run_forever(self) -> None:
         """Process events forever."""
-        await self.run_until(lambda _: False)
+        self.run_until(lambda _: False)
 
-    async def run_until(self, func: Callable[[AttrDict], Union[bool, Coroutine]]) -> AttrDict:
+    def run_until(self, func: Callable[[AttrDict], bool]) -> AttrDict:
         """Process events until the given callable evaluates to True.
 
         The callable should accept an AttrDict object representing the
@@ -101,39 +99,37 @@ class Client:
         evaluates to True.
         """
         self.logger.debug("Listening to incoming events...")
-        if await self.is_configured():
-            await self.account.start_io()
-        await self._process_messages()  # Process old messages.
+        if self.is_configured():
+            self.account.start_io()
+        self._process_messages()  # Process old messages.
         while True:
-            event = await self.account.wait_for_event()
+            event = self.account.wait_for_event()
             event["kind"] = EventType(event.kind)
             event["account"] = self.account
-            await self._on_event(event)
+            self._on_event(event)
             if event.kind == EventType.INCOMING_MSG:
-                await self._process_messages()
+                self._process_messages()
 
             stop = func(event)
-            if inspect.isawaitable(stop):
-                stop = await stop
             if stop:
                 return event
 
-    async def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
+    def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
         for hook, evfilter in self._hooks.get(filter_type, []):
-            if await evfilter.filter(event):
+            if evfilter.filter(event):
                 try:
-                    await hook(event)
+                    hook(event)
                 except Exception as ex:
                     self.logger.exception(ex)
 
-    async def _parse_command(self, event: AttrDict) -> None:
+    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 = "@" + (await self.account.self_contact.get_snapshot()).address
+            suffix = "@" + self.account.self_contact.get_snapshot().address
             if cmd.endswith(suffix):
                 cmd = cmd[: -len(suffix)]
             else:
@@ -153,32 +149,32 @@ class Client:
 
         event["command"], event["payload"] = cmd, payload
 
-    async def _on_new_msg(self, snapshot: AttrDict) -> None:
+    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):
-            await self._parse_command(event)
-        await self._on_event(event, NewMessage)
+            self._parse_command(event)
+        self._on_event(event, NewMessage)
 
-    async def _handle_info_msg(self, snapshot: AttrDict) -> None:
+    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
-            await self._on_event(event, GroupImageChanged)
+            self._on_event(event, GroupImageChanged)
             return
 
         title_changed = parse_system_title_changed(snapshot.text)
         if title_changed:
             _, event["old_name"] = title_changed
-            await self._on_event(event, GroupNameChanged)
+            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"
-            await self._on_event(event, MemberListChanged)
+            self._on_event(event, MemberListChanged)
             return
 
         self.logger.warning(
@@ -187,20 +183,20 @@ class Client:
             snapshot.text,
         )
 
-    async def _process_messages(self) -> None:
+    def _process_messages(self) -> None:
         if self._should_process_messages:
-            for message in await self.account.get_next_messages():
-                snapshot = await message.get_snapshot()
+            for message in self.account.get_next_messages():
+                snapshot = message.get_snapshot()
                 if snapshot.from_id not in [SpecialContactId.SELF, SpecialContactId.DEVICE]:
-                    await self._on_new_msg(snapshot)
+                    self._on_new_msg(snapshot)
                 if snapshot.is_info and snapshot.system_message_type != SystemMessageType.WEBXDC_INFO_MESSAGE:
-                    await self._handle_info_msg(snapshot)
-                await snapshot.message.mark_seen()
+                    self._handle_info_msg(snapshot)
+                snapshot.message.mark_seen()
 
 
 class Bot(Client):
     """Simple bot implementation that listent to events of a single account."""
 
-    async def configure(self, email: str, password: str, **kwargs) -> None:
+    def configure(self, email: str, password: str, **kwargs) -> None:
         kwargs.setdefault("bot", "1")
-        await super().configure(email, password, **kwargs)
+        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
 
-    async def block(self) -> None:
+    def block(self) -> None:
         """Block contact."""
-        await self._rpc.block_contact(self.account.id, self.id)
+        self._rpc.block_contact(self.account.id, self.id)
 
-    async def unblock(self) -> None:
+    def unblock(self) -> None:
         """Unblock contact."""
-        await self._rpc.unblock_contact(self.account.id, self.id)
+        self._rpc.unblock_contact(self.account.id, self.id)
 
-    async def delete(self) -> None:
+    def delete(self) -> None:
         """Delete contact."""
-        await self._rpc.delete_contact(self.account.id, self.id)
+        self._rpc.delete_contact(self.account.id, self.id)
 
-    async def set_name(self, name: str) -> None:
+    def set_name(self, name: str) -> None:
         """Change the name of this contact."""
-        await self._rpc.change_contact_name(self.account.id, self.id, name)
+        self._rpc.change_contact_name(self.account.id, self.id, name)
 
-    async def get_encryption_info(self) -> str:
+    def get_encryption_info(self) -> str:
         """Get a multi-line encryption info, containing your fingerprint and
         the fingerprint of the contact.
         """
-        return await self._rpc.get_contact_encryption_info(self.account.id, self.id)
+        return self._rpc.get_contact_encryption_info(self.account.id, self.id)
 
-    async def get_snapshot(self) -> AttrDict:
+    def get_snapshot(self) -> AttrDict:
         """Return a dictionary with a snapshot of all contact properties."""
-        snapshot = AttrDict(await self._rpc.get_contact(self.account.id, self.id))
+        snapshot = AttrDict(self._rpc.get_contact(self.account.id, self.id))
         snapshot["contact"] = self
         return snapshot
 
-    async def create_chat(self) -> "Chat":
+    def create_chat(self) -> "Chat":
         """Create or get an existing 1:1 chat for this contact."""
         from .chat import Chat
 
         return Chat(
             self.account,
-            await self._rpc.create_chat_by_contact_id(self.account.id, self.id),
+            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
 
-    async def add_account(self) -> Account:
+    def add_account(self) -> Account:
         """Create a new account database."""
-        account_id = await self.rpc.add_account()
+        account_id = self.rpc.add_account()
         return Account(self, account_id)
 
-    async def get_all_accounts(self) -> List[Account]:
+    def get_all_accounts(self) -> List[Account]:
         """Return a list of all available accounts."""
-        account_ids = await self.rpc.get_all_account_ids()
+        account_ids = self.rpc.get_all_account_ids()
         return [Account(self, account_id) for account_id in account_ids]
 
-    async def start_io(self) -> None:
+    def start_io(self) -> None:
         """Start the I/O of all accounts."""
-        await self.rpc.start_io_for_all_accounts()
+        self.rpc.start_io_for_all_accounts()
 
-    async def stop_io(self) -> None:
+    def stop_io(self) -> None:
         """Stop the I/O of all accounts."""
-        await self.rpc.stop_io_for_all_accounts()
+        self.rpc.stop_io_for_all_accounts()
 
-    async def maybe_network(self) -> None:
+    def maybe_network(self) -> None:
         """Indicate that the network likely has come back or just that the network
         conditions might have changed.
         """
-        await self.rpc.maybe_network()
+        self.rpc.maybe_network()
 
-    async def get_system_info(self) -> AttrDict:
+    def get_system_info(self) -> AttrDict:
         """Get information about the Delta Chat core in this system."""
-        return AttrDict(await self.rpc.get_system_info())
+        return AttrDict(self.rpc.get_system_info())
 
-    async def set_translations(self, translations: Dict[str, str]) -> None:
+    def set_translations(self, translations: Dict[str, str]) -> None:
         """Set stock translation strings."""
-        await self.rpc.set_stock_strings(translations)
+        self.rpc.set_stock_strings(translations)

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

@@ -1,5 +1,4 @@
 """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
@@ -24,7 +23,7 @@ def _tuple_of(obj, type_: type) -> tuple:
 class EventFilter(ABC):
     """The base event filter.
 
-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -43,16 +42,13 @@ class EventFilter(ABC):
     def __ne__(self, other):
         return not self == other
 
-    async def _call_func(self, event) -> bool:
+    def _call_func(self, event) -> bool:
         if not self.func:
             return True
-        res = self.func(event)
-        if inspect.isawaitable(res):
-            return await res
-        return res
+        return self.func(event)
 
     @abstractmethod
-    async def filter(self, event):
+    def filter(self, event):
         """Return True-like value if the event passed the filter and should be
         used, or False-like value otherwise.
         """
@@ -62,7 +58,7 @@ class RawEvent(EventFilter):
     """Matches raw core events.
 
     :param types: The types of event to match.
-    :param func: A Callable (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -82,10 +78,10 @@ class RawEvent(EventFilter):
             return (self.types, self.func) == (other.types, other.func)
         return False
 
-    async def filter(self, event: "AttrDict") -> bool:
+    def filter(self, event: "AttrDict") -> bool:
         if self.types and event.kind not in self.types:
             return False
-        return await self._call_func(event)
+        return self._call_func(event)
 
 
 class NewMessage(EventFilter):
@@ -104,7 +100,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 (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -159,7 +155,7 @@ class NewMessage(EventFilter):
             )
         return False
 
-    async def filter(self, event: "AttrDict") -> bool:
+    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:
@@ -168,11 +164,9 @@ 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 await super()._call_func(event)
+        return super()._call_func(event)
 
 
 class MemberListChanged(EventFilter):
@@ -184,7 +178,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 (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -201,10 +195,10 @@ class MemberListChanged(EventFilter):
             return (self.added, self.func) == (other.added, other.func)
         return False
 
-    async def filter(self, event: "AttrDict") -> bool:
+    def filter(self, event: "AttrDict") -> bool:
         if self.added is not None and self.added != event.member_added:
             return False
-        return await self._call_func(event)
+        return self._call_func(event)
 
 
 class GroupImageChanged(EventFilter):
@@ -216,7 +210,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 (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -233,10 +227,10 @@ class GroupImageChanged(EventFilter):
             return (self.deleted, self.func) == (other.deleted, other.func)
         return False
 
-    async def filter(self, event: "AttrDict") -> bool:
+    def filter(self, event: "AttrDict") -> bool:
         if self.deleted is not None and self.deleted != event.image_deleted:
             return False
-        return await self._call_func(event)
+        return self._call_func(event)
 
 
 class GroupNameChanged(EventFilter):
@@ -245,7 +239,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 (async or not) function that should accept the event as input
+    :param func: A Callable function that should accept the event as input
                  parameter, and return a bool value indicating whether the event
                  should be dispatched or not.
     """
@@ -258,8 +252,8 @@ class GroupNameChanged(EventFilter):
             return self.func == other.func
         return False
 
-    async def filter(self, event: "AttrDict") -> bool:
-        return await self._call_func(event)
+    def filter(self, event: "AttrDict") -> bool:
+        return 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
 
-    async def send_reaction(self, *reaction: str):
+    def send_reaction(self, *reaction: str):
         """Send a reaction to this message."""
-        await self._rpc.send_reaction(self.account.id, self.id, reaction)
+        self._rpc.send_reaction(self.account.id, self.id, reaction)
 
-    async def get_snapshot(self) -> AttrDict:
+    def get_snapshot(self) -> AttrDict:
         """Get a snapshot with the properties of this message."""
         from .chat import Chat
 
-        snapshot = AttrDict(await self._rpc.get_message(self.account.id, self.id))
+        snapshot = AttrDict(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
 
-    async def get_reactions(self) -> Optional[AttrDict]:
+    def get_reactions(self) -> Optional[AttrDict]:
         """Get message reactions."""
-        reactions = await self._rpc.get_message_reactions(self.account.id, self.id)
+        reactions = self._rpc.get_message_reactions(self.account.id, self.id)
         if reactions:
             return AttrDict(reactions)
         return None
 
-    async def mark_seen(self) -> None:
+    def mark_seen(self) -> None:
         """Mark the message as seen."""
-        await self._rpc.markseen_msgs(self.account.id, [self.id])
+        self._rpc.markseen_msgs(self.account.id, [self.id])
 
-    async def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
+    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)
-        await self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
+        self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
 
-    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_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_info(self) -> dict:
-        return await self._rpc.get_webxdc_info(self.account.id, self.id)
+    def get_webxdc_info(self) -> dict:
+        return self._rpc.get_webxdc_info(self.account.id, self.id)

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

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

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

@@ -1,6 +1,10 @@
-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
 
 
@@ -10,7 +14,7 @@ class JsonRpcError(Exception):
 
 class Rpc:
     def __init__(self, accounts_dir: Optional[str] = None, **kwargs):
-        """The given arguments will be passed to asyncio.create_subprocess_exec()"""
+        """The given arguments will be passed to subprocess.Popen()"""
         if accounts_dir:
             kwargs["env"] = {
                 **kwargs.get("env", os.environ),
@@ -18,95 +22,142 @@ class Rpc:
             }
 
         self._kwargs = kwargs
-        self.process: asyncio.subprocess.Process
+        self.process: subprocess.Popen
         self.id: int
-        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.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.closing: bool
-        self.reader_task: asyncio.Task
-        self.events_task: asyncio.Task
+        self.reader_thread: Thread
+        self.writer_thread: Thread
+        self.events_thread: Thread
 
-    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,
-        )
+    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,
+            )
         self.id = 0
         self.event_queues = {}
         self.request_events = {}
+        self.request_results = {}
+        self.request_queue = Queue()
         self.closing = False
-        self.reader_task = asyncio.create_task(self.reader_loop())
-        self.events_task = asyncio.create_task(self.events_loop())
+        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()
 
-    async def close(self) -> None:
+    def close(self) -> None:
         """Terminate RPC server process and wait until the reader loop finishes."""
         self.closing = True
-        await self.stop_io_for_all_accounts()
-        await self.events_task
-        self.process.terminate()
-        await self.reader_task
+        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()
 
-    async def __aenter__(self):
-        await self.start()
+    def __enter__(self):
+        self.start()
         return self
 
-    async def __aexit__(self, _exc_type, _exc, _tb):
-        await self.close()
+    def __exit__(self, _exc_type, _exc, _tb):
+        self.close()
 
-    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 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 get_queue(self, account_id: int) -> asyncio.Queue:
+    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:
         if account_id not in self.event_queues:
-            self.event_queues[account_id] = asyncio.Queue()
+            self.event_queues[account_id] = Queue()
         return self.event_queues[account_id]
 
-    async def events_loop(self) -> None:
+    def events_loop(self) -> None:
         """Requests new events and distributes them between queues."""
-        while True:
-            if self.closing:
-                return
-            event = await self.get_next_event()
-            account_id = event["contextId"]
-            queue = await self.get_queue(account_id)
-            await queue.put(event["event"])
+        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")
 
-    async def wait_for_event(self, account_id: int) -> Optional[dict]:
+    def wait_for_event(self, account_id: int) -> Optional[dict]:
         """Waits for the next event from the given account and returns it."""
-        queue = await self.get_queue(account_id)
-        return await queue.get()
+        queue = self.get_queue(account_id)
+        return queue.get()
 
     def __getattr__(self, attr: str):
-        async def method(*args, **kwargs) -> Any:
+        def method(*args) -> Any:
             self.id += 1
             request_id = self.id
 
-            assert not (args and kwargs), "Mixing positional and keyword arguments"
-
             request = {
                 "jsonrpc": "2.0",
                 "method": attr,
-                "params": kwargs or args,
+                "params": args,
                 "id": self.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
+            event = Event()
+            self.request_events[request_id] = event
+            self.request_queue.put(request)
+            event.wait()
+
+            response = self.request_results.pop(request_id)
             if "error" in response:
                 raise JsonRpcError(response["error"])
             if "result" in response:

deltachat-rpc-client/tests/test_something.py

@@ -1,4 +1,4 @@
-import asyncio
+import concurrent.futures
 import json
 import subprocess
 from unittest.mock import MagicMock
@@ -8,26 +8,26 @@ from deltachat_rpc_client import EventType, events
 from deltachat_rpc_client.rpc import JsonRpcError
 
 
-@pytest.mark.asyncio()
-async def test_system_info(rpc) -> None:
-    system_info = await rpc.get_system_info()
+def test_system_info(rpc) -> None:
+    system_info = rpc.get_system_info()
     assert "arch" in system_info
     assert "deltachat_core_version" in system_info
 
 
-@pytest.mark.asyncio()
-async def test_sleep(rpc) -> None:
+def test_sleep(rpc) -> None:
     """Test that long-running task does not block short-running task from completion."""
-    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()
+    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
 
 
-@pytest.mark.asyncio()
-async def test_email_address_validity(rpc) -> None:
+def test_email_address_validity(rpc) -> None:
     valid_addresses = [
         "email@example.com",
         "36aa165ae3406424e0c61af17700f397cad3fe8ab83d682d0bddf3338a5dd52e@yggmail@yggmail",
@@ -35,16 +35,15 @@ async def test_email_address_validity(rpc) -> None:
     invalid_addresses = ["email@", "example.com", "emai221"]
 
     for addr in valid_addresses:
-        assert await rpc.check_email_validity(addr)
+        assert rpc.check_email_validity(addr)
     for addr in invalid_addresses:
-        assert not await rpc.check_email_validity(addr)
+        assert not rpc.check_email_validity(addr)
 
 
-@pytest.mark.asyncio()
-async def test_acfactory(acfactory) -> None:
-    account = await acfactory.new_configured_account()
+def test_acfactory(acfactory) -> None:
+    account = acfactory.new_configured_account()
     while True:
-        event = await account.wait_for_event()
+        event = account.wait_for_event()
         if event.kind == EventType.CONFIGURE_PROGRESS:
             assert event.progress != 0  # Progress 0 indicates error.
             if event.progress == 1000:  # Success
@@ -54,248 +53,241 @@ async def test_acfactory(acfactory) -> None:
     print("Successful configuration")
 
 
-@pytest.mark.asyncio()
-async def test_configure_starttls(acfactory) -> None:
-    account = await acfactory.new_preconfigured_account()
+def test_configure_starttls(acfactory) -> None:
+    account = acfactory.new_preconfigured_account()
 
     # Use STARTTLS
-    await account.set_config("mail_security", "2")
-    await account.set_config("send_security", "2")
-    await account.configure()
-    assert await account.is_configured()
+    account.set_config("mail_security", "2")
+    account.set_config("send_security", "2")
+    account.configure()
+    assert account.is_configured()
 
 
-@pytest.mark.asyncio()
-async def test_account(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_account(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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!")
+    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!")
 
     while True:
-        event = await bob.wait_for_event()
+        event = bob.wait_for_event()
         if event.kind == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
     message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
     assert snapshot.chat_id == chat_id
     assert snapshot.text == "Hello!"
-    await bob.mark_seen_messages([message])
+    bob.mark_seen_messages([message])
 
     assert alice != bob
     assert repr(alice)
-    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.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 alice.self_contact
-    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()
+    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()
 
     # Test sending empty message.
-    assert len(await bob.wait_next_messages()) == 0
-    await alice_chat_bob.send_text("")
-    messages = await bob.wait_next_messages()
+    assert len(bob.wait_next_messages()) == 0
+    alice_chat_bob.send_text("")
+    messages = bob.wait_next_messages()
     assert len(messages) == 1
     message = messages[0]
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
     assert snapshot.text == ""
-    await bob.mark_seen_messages([message])
+    bob.mark_seen_messages([message])
 
-    group = await alice.create_group("test group")
-    await group.add_contact(alice_contact_bob)
-    group_msg = await group.send_message(text="hello")
+    group = alice.create_group("test group")
+    group.add_contact(alice_contact_bob)
+    group_msg = 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)
-    await alice.delete_messages([group_msg])
+    alice.delete_messages([group_msg])
 
-    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"
+    alice.set_config("selfstatus", "test")
+    assert alice.get_config("selfstatus") == "test"
+    alice.update_config(selfstatus="test2")
+    assert alice.get_config("selfstatus") == "test2"
 
-    assert not await alice.get_blocked_contacts()
-    await alice_contact_bob.block()
-    blocked_contacts = await alice.get_blocked_contacts()
+    assert not alice.get_blocked_contacts()
+    alice_contact_bob.block()
+    blocked_contacts = alice.get_blocked_contacts()
     assert blocked_contacts
     assert blocked_contacts[0].contact == alice_contact_bob
 
-    await bob.remove()
-    await alice.stop_io()
+    bob.remove()
+    alice.stop_io()
 
 
-@pytest.mark.asyncio()
-async def test_chat(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_chat(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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!")
+    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!")
 
     while True:
-        event = await bob.wait_for_event()
+        event = bob.wait_for_event()
         if event.kind == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
     message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = 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)
-    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()
+    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()
     with pytest.raises(JsonRpcError):  # can't set name for 1:1 chats
-        await bob_chat_alice.set_name("test")
-    await bob_chat_alice.set_ephemeral_timer(300)
-    await bob_chat_alice.get_encryption_info()
+        bob_chat_alice.set_name("test")
+    bob_chat_alice.set_ephemeral_timer(300)
+    bob_chat_alice.get_encryption_info()
 
-    group = await alice.create_group("test group")
-    await group.add_contact(alice_contact_bob)
-    await group.get_qr_code()
+    group = alice.create_group("test group")
+    group.add_contact(alice_contact_bob)
+    group.get_qr_code()
 
-    snapshot = await group.get_basic_snapshot()
+    snapshot = group.get_basic_snapshot()
     assert snapshot.name == "test group"
-    await group.set_name("new name")
-    snapshot = await group.get_full_snapshot()
+    group.set_name("new name")
+    snapshot = group.get_full_snapshot()
     assert snapshot.name == "new name"
 
-    msg = await group.send_message(text="hi")
-    assert (await msg.get_snapshot()).text == "hi"
-    await group.forward_messages([msg])
+    msg = group.send_message(text="hi")
+    assert (msg.get_snapshot()).text == "hi"
+    group.forward_messages([msg])
 
-    await group.set_draft(text="test draft")
-    draft = await group.get_draft()
+    group.set_draft(text="test draft")
+    draft = group.get_draft()
     assert draft.text == "test draft"
-    await group.remove_draft()
-    assert not await group.get_draft()
+    group.remove_draft()
+    assert not group.get_draft()
 
-    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()
+    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()
 
 
-@pytest.mark.asyncio()
-async def test_contact(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_contact(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    bob_addr = await bob.get_config("addr")
-    alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
 
     assert alice_contact_bob == alice.get_contact_by_id(alice_contact_bob.id)
     assert repr(alice_contact_bob)
-    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()
+    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()
     assert snapshot.address == bob_addr
-    await alice_contact_bob.create_chat()
+    alice_contact_bob.create_chat()
 
 
-@pytest.mark.asyncio()
-async def test_message(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_message(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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!")
+    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!")
 
     while True:
-        event = await bob.wait_for_event()
+        event = bob.wait_for_event()
         if event.kind == EventType.INCOMING_MSG:
             chat_id = event.chat_id
             msg_id = event.msg_id
             break
 
     message = bob.get_message_by_id(msg_id)
-    snapshot = await message.get_snapshot()
+    snapshot = 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
-        await snapshot.chat.send_text("hi")
-    await snapshot.chat.accept()
-    await snapshot.chat.send_text("hi")
+        snapshot.chat.send_text("hi")
+    snapshot.chat.accept()
+    snapshot.chat.send_text("hi")
 
-    await message.mark_seen()
-    await message.send_reaction("😎")
-    reactions = await message.get_reactions()
+    message.mark_seen()
+    message.send_reaction("😎")
+    reactions = message.get_reactions()
     assert reactions
-    snapshot = await message.get_snapshot()
+    snapshot = message.get_snapshot()
     assert reactions == snapshot.reactions
 
 
-@pytest.mark.asyncio()
-async def test_is_bot(acfactory) -> None:
+def test_is_bot(acfactory) -> None:
     """Test that we can recognize messages submitted by bots."""
-    alice, bob = await acfactory.get_online_accounts(2)
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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()
+    bob_addr = bob.get_config("addr")
+    alice_contact_bob = alice.create_contact(bob_addr, "Bob")
+    alice_chat_bob = alice_contact_bob.create_chat()
 
     # Alice becomes a bot.
-    await alice.set_config("bot", "1")
-    await alice_chat_bob.send_text("Hello!")
+    alice.set_config("bot", "1")
+    alice_chat_bob.send_text("Hello!")
 
     while True:
-        event = await bob.wait_for_event()
+        event = bob.wait_for_event()
         if event.kind == EventType.INCOMING_MSG:
             msg_id = event.msg_id
             message = bob.get_message_by_id(msg_id)
-            snapshot = await message.get_snapshot()
+            snapshot = message.get_snapshot()
             assert snapshot.chat_id == event.chat_id
             assert snapshot.text == "Hello!"
             assert snapshot.is_bot
             break
 
 
-@pytest.mark.asyncio()
-async def test_bot(acfactory) -> None:
+def test_bot(acfactory) -> None:
     mock = MagicMock()
-    user = (await acfactory.get_online_accounts(1))[0]
-    bot = await acfactory.new_configured_bot()
-    bot2 = await acfactory.new_configured_bot()
+    user = (acfactory.get_online_accounts(1))[0]
+    bot = acfactory.new_configured_bot()
+    bot2 = acfactory.new_configured_bot()
 
-    assert await bot.is_configured()
-    assert await bot.account.get_config("bot") == "1"
+    assert bot.is_configured()
+    assert 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 = 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()
+    event = acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
+    snapshot = 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)
@@ -307,58 +299,57 @@ async def test_bot(acfactory) -> None:
     hook = track, events.NewMessage(r"hello")
     bot.add_hook(*hook)
     bot.add_hook(track, events.NewMessage(command="/help"))
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="hello")
     mock.hook.assert_called_with(event.msg_id)
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello!")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="hello!")
     mock.hook.assert_called_with(event.msg_id)
-    await acfactory.process_message(from_account=bot2.account, to_client=bot, text="hello")
+    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
-    await acfactory.process_message(from_account=user, to_client=bot, text="hey!")
+    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()
-    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")
+    acfactory.process_message(from_account=user, to_client=bot, text="hello")
+    event = acfactory.process_message(from_account=user, to_client=bot, text="/help")
     mock.hook.assert_called_once_with(event.msg_id)
 
 
-@pytest.mark.asyncio()
-async def test_wait_next_messages(acfactory) -> None:
-    alice = await acfactory.new_configured_account()
+def test_wait_next_messages(acfactory) -> None:
+    alice = acfactory.new_configured_account()
 
     # Create a bot account so it does not receive device messages in the beginning.
-    bot = await acfactory.new_preconfigured_account()
-    await bot.set_config("bot", "1")
-    await bot.configure()
+    bot = acfactory.new_preconfigured_account()
+    bot.set_config("bot", "1")
+    bot.configure()
 
     # There are no old messages and the call returns immediately.
-    assert not await bot.wait_next_messages()
+    assert not bot.wait_next_messages()
 
-    # Bot starts waiting for messages.
-    next_messages_task = asyncio.create_task(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_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!")
+        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!")
 
-    next_messages = await next_messages_task
-    assert len(next_messages) == 1
-    snapshot = await next_messages[0].get_snapshot()
-    assert snapshot.text == "Hello!"
+        next_messages = next_messages_task.result()
+        assert len(next_messages) == 1
+        snapshot = next_messages[0].get_snapshot()
+        assert snapshot.text == "Hello!"
 
 
-@pytest.mark.asyncio()
-async def test_import_export(acfactory, tmp_path) -> None:
-    alice = await acfactory.new_configured_account()
-    await alice.export_backup(tmp_path)
+def test_import_export(acfactory, tmp_path) -> None:
+    alice = acfactory.new_configured_account()
+    alice.export_backup(tmp_path)
 
     files = list(tmp_path.glob("*.tar"))
-    alice2 = await acfactory.get_unconfigured_account()
-    await alice2.import_backup(files[0])
+    alice2 = acfactory.get_unconfigured_account()
+    alice2.import_backup(files[0])
 
-    assert await alice2.manager.get_system_info()
+    assert alice2.manager.get_system_info()
 
 
 def test_openrpc_command_line() -> None:

deltachat-rpc-client/tests/test_webxdc.py

@@ -1,24 +1,22 @@
-import pytest
 from deltachat_rpc_client import EventType
 
 
-@pytest.mark.asyncio()
-async def test_webxdc(acfactory) -> None:
-    alice, bob = await acfactory.get_online_accounts(2)
+def test_webxdc(acfactory) -> None:
+    alice, bob = acfactory.get_online_accounts(2)
 
-    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")
+    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")
 
     while True:
-        event = await bob.wait_for_event()
+        event = bob.wait_for_event()
         if event.kind == 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 = await message.get_webxdc_info()
+    webxdc_info = message.get_webxdc_info()
     assert webxdc_info == {
         "document": None,
         "icon": "icon.png",
@@ -28,20 +26,20 @@ async def test_webxdc(acfactory) -> None:
         "summary": None,
     }
 
-    status_updates = await message.get_webxdc_status_updates()
+    status_updates = message.get_webxdc_status_updates()
     assert status_updates == []
 
-    await bob_chat_alice.accept()
-    await message.send_webxdc_status_update({"payload": 42}, "")
-    await message.send_webxdc_status_update({"payload": "Second update"}, "description")
+    bob_chat_alice.accept()
+    message.send_webxdc_status_update({"payload": 42}, "")
+    message.send_webxdc_status_update({"payload": "Second update"}, "description")
 
-    status_updates = await message.get_webxdc_status_updates()
+    status_updates = 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 = await message.get_webxdc_status_updates(1)
+    status_updates = 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 {posargs}
+    pytest -n6 {posargs}
 setenv =
 # Avoid stack overflow when Rust core is built without optimizations.
     RUST_MIN_STACK=8388608
@@ -14,10 +14,8 @@ passenv =
     DCC_NEW_TMP_EMAIL
 deps =
     pytest
-    pytest-asyncio
     pytest-timeout
-    aiohttp
-    aiodns
+    pytest-xdist
 
 [testenv:lint]
 skipsdist = True

deltachat-rpc-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.119.0"
+version = "1.127.0"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
@@ -15,12 +15,12 @@ deltachat = { path = "..", default-features = false }
 
 anyhow = "1"
 env_logger = { version = "0.10.0" }
-futures-lite = "1.13.0"
+futures-lite = "2.0.0"
 log = "0.4"
-serde_json = "1.0.99"
+serde_json = "1.0.105"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.29.1", features = ["io-std"] }
-tokio-util = "0.7.8"
+tokio = { version = "1.33.0", features = ["io-std"] }
+tokio-util = "0.7.9"
 yerpc = { version = "0.5.2", features = ["anyhow_expose", "openrpc"] }
 
 [features]

deny.toml

@@ -24,10 +24,8 @@ skip = [
      { name = "digest", version = "<0.10" },
      { name = "ed25519-dalek", version = "1.0.1" },
      { name = "ed25519", version = "1.5.3" },
-     { name = "fastrand", version = "1.9.0" },
      { name = "getrandom", version = "<0.2" },
      { name = "hashbrown", version = "<0.14.0" },
-     { name = "idna", version = "<0.3" },
      { name = "indexmap", version = "<2.0.0" },
      { name = "pem-rfc7468", version = "0.6.0" },
      { name = "pkcs8", version = "0.9.0" },
@@ -37,6 +35,7 @@ skip = [
      { name = "rand", version = "<0.8" },
      { name = "redox_syscall", version = "0.2.16" },
      { name = "regex-automata", version = "0.1.10" },
+     { name = "ring", version = "0.16.20" },
      { name = "regex-syntax", version = "0.6.29" },
      { name = "sec1", version = "0.3.0" },
      { name = "sha2", version = "<0.10" },
@@ -46,18 +45,14 @@ skip = [
      { name = "spki", version = "0.6.0" },
      { name = "syn", version = "1.0.109" },
      { name = "time", version = "<0.3" },
+     { name = "untrusted", version = "0.7.1" },
      { name = "wasi", version = "<0.11" },
-     { name = "windows_aarch64_gnullvm", version = "<0.48" },
      { name = "windows_aarch64_msvc", version = "<0.48" },
      { name = "windows_i686_gnu", version = "<0.48" },
      { name = "windows_i686_msvc", version = "<0.48" },
-     { name = "windows-sys", version = "<0.48" },
-     { name = "windows-targets", version = "<0.48" },
      { name = "windows", version = "0.32.0" },
-     { name = "windows_x86_64_gnullvm", version = "<0.48" },
      { name = "windows_x86_64_gnu", version = "<0.48" },
      { name = "windows_x86_64_msvc", version = "<0.48" },
-     { name = "winreg", version = "0.10.1" },
 ]
 
 
@@ -89,5 +84,4 @@ license-files = [
 github = [
        "async-email",
        "deltachat",
-       "quinn-rs",
 ]

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 wast 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 waste that much development time.)
 
 [full messages](https://github.com/deltachat/deltachat-core-rust/pull/2896#discussion_r852002161)
   

fuzz/Cargo.lock

@@ -177,13 +177,13 @@ dependencies = [
 
 [[package]]
 name = "async-imap"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da93622739d458dd9a6abc1abf0e38e81965a5824a3b37f9500437c82a8bb572"
+checksum = "b538b767cbf9c162a6c5795d4b932bd2c20ba10b5a91a94d2b2b6886c1dce6a8"
 dependencies = [
  "async-channel",
  "base64 0.21.0",
- "byte-pool",
+ "bytes",
  "chrono",
  "futures",
  "imap-proto",
@@ -337,9 +337,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.0.2"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "487f1e0fcbe47deb8b0574e646def1c903389d95241dd1bbcc6ce4a715dfc0c1"
+checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
 
 [[package]]
 name = "blake3"
@@ -529,16 +529,6 @@ version = "3.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
 
-[[package]]
-name = "byte-pool"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f1b21189f50b5625efa6227cf45e9d4cfdc2e73582df2b879e9689e78a7158"
-dependencies = [
- "crossbeam-queue",
- "stable_deref_trait",
-]
-
 [[package]]
 name = "bytemuck"
 version = "1.12.3"
@@ -741,16 +731,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "crossbeam-queue"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.14"
@@ -926,7 +906,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat"
-version = "1.117.0"
+version = "1.123.0"
 dependencies = [
  "anyhow",
  "async-channel",
@@ -943,6 +923,7 @@ dependencies = [
  "encoded-words",
  "escaper",
  "fast-socks5",
+ "fd-lock",
  "format-flowed",
  "futures",
  "futures-lite",
@@ -955,7 +936,7 @@ dependencies = [
  "libc",
  "mailparse 0.14.0",
  "mime",
- "num-derive",
+ "num-derive 0.4.0",
  "num-traits",
  "num_cpus",
  "once_cell",
@@ -1429,14 +1410,14 @@ checksum = "b5320ae4c3782150d900b79807611a59a99fc9a1d61d686faafc24b93fc8d7ca"
 
 [[package]]
 name = "enum-as-inner"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116"
+checksum = "5ffccbb6966c05b32ef8fbac435df276c4ae4d3dc55a8cd0eb9745e6c12f546a"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.15",
 ]
 
 [[package]]
@@ -1464,6 +1445,17 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "errno"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "errno-dragonfly"
 version = "0.1.2"
@@ -1532,6 +1524,17 @@ dependencies = [
  "instant",
 ]
 
+[[package]]
+name = "fd-lock"
+version = "3.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef033ed5e9bad94e55838ca0ca906db0e043f517adda0c8b79c7a8c66c93c1b5"
+dependencies = [
+ "cfg-if",
+ "rustix 0.38.14",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "ff"
 version = "0.12.1"
@@ -1616,9 +1619,9 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
 dependencies = [
  "percent-encoding",
 ]
@@ -1843,18 +1846,15 @@ dependencies = [
 
 [[package]]
 name = "heck"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
 [[package]]
 name = "hermit-abi"
-version = "0.2.6"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
-]
+checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7"
 
 [[package]]
 name = "hex"
@@ -1951,7 +1951,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2",
+ "socket2 0.4.7",
  "tokio",
  "tower-service",
  "tracing",
@@ -2012,20 +2012,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
 name = "idna"
-version = "0.2.3"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "idna"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
 dependencies = [
  "unicode-bidi",
  "unicode-normalization",
@@ -2033,9 +2022,9 @@ dependencies = [
 
 [[package]]
 name = "image"
-version = "0.24.6"
+version = "0.24.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "527909aa81e20ac3a44803521443a765550f09b5130c2c2fa1ea59c2f8f50a3a"
+checksum = "6f3dfdbdd72063086ff443e297b61695500514b1e41095b6fb9a5ab48a70a711"
 dependencies = [
  "bytemuck",
  "byteorder",
@@ -2100,10 +2089,10 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd302af1b90f2463a98fa5ad469fc212c8e3175a41c3068601bfa2727591c5be"
 dependencies = [
- "socket2",
+ "socket2 0.4.7",
  "widestring",
  "winapi",
- "winreg",
+ "winreg 0.10.1",
 ]
 
 [[package]]
@@ -2230,9 +2219,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.139"
+version = "0.2.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
+checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"
 
 [[package]]
 name = "libm"
@@ -2279,6 +2268,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a9bad9f94746442c783ca431b22403b519cd7fbeed0533fdd6328b2f2212128"
+
 [[package]]
 name = "lock_api"
 version = "0.4.9"
@@ -2341,15 +2336,9 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
 dependencies = [
- "regex-automata",
+ "regex-automata 0.1.10",
 ]
 
-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
 [[package]]
 name = "md-5"
 version = "0.10.5"
@@ -2367,9 +2356,9 @@ checksum = "df39d232f5c40b0891c10216992c2f250c054105cb1e56f0fc9032db6203ecc1"
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
 
 [[package]]
 name = "mime"
@@ -2394,14 +2383,13 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2"
 dependencies = [
  "libc",
- "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2555,6 +2543,17 @@ dependencies = [
  "syn 1.0.107",
 ]
 
+[[package]]
+name = "num-derive"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e6a0fd4f737c707bd9086cc16c925f294943eb62eb71499e9fd4cf71f8b9f4e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.15",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.45"
@@ -2599,9 +2598,9 @@ dependencies = [
 
 [[package]]
 name = "num_cpus"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
  "hermit-abi",
  "libc",
@@ -2854,7 +2853,7 @@ dependencies = [
  "md-5",
  "nom",
  "num-bigint-dig",
- "num-derive",
+ "num-derive 0.3.3",
  "num-traits",
  "p256 0.13.1",
  "p384 0.13.0",
@@ -2894,9 +2893,9 @@ dependencies = [
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.9"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
 
 [[package]]
 name = "pin-utils"
@@ -3087,9 +3086,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
 [[package]]
 name = "quick-xml"
-version = "0.28.2"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce5e73202a820a31f8a0ee32ada5e21029c81fd9e3ebf668a40832e4219d9d1"
+checksum = "eff6510e86862b57b210fd8cbe8ed3f0d7d600b9c2863cd4549a2e033c66e956"
 dependencies = [
  "memchr",
 ]
@@ -3114,9 +3113,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.9.2"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72ef4ced82a24bb281af338b9e8f94429b6eca01b4e66d899f40031f074e74c9"
+checksum = "c956be1b23f4261676aed05a0046e204e8a6836e50203902683a718af0797989"
 dependencies = [
  "bytes",
  "rand 0.8.5",
@@ -3139,7 +3138,7 @@ checksum = "641538578b21f5e5c8ea733b736895576d0fe329bb883b937db6f4d163dbaaf4"
 dependencies = [
  "libc",
  "quinn-proto",
- "socket2",
+ "socket2 0.4.7",
  "tracing",
  "windows-sys 0.42.0",
 ]
@@ -3268,13 +3267,14 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.8.4"
+version = "1.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0ab3ca65655bb1e41f2a8c8cd662eb4fb035e67c3f78da1d61dffe89d07300f"
+checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.7.2",
+ "regex-automata 0.3.8",
+ "regex-syntax 0.7.5",
 ]
 
 [[package]]
@@ -3286,6 +3286,17 @@ dependencies = [
  "regex-syntax 0.6.28",
 ]
 
+[[package]]
+name = "regex-automata"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.7.5",
+]
+
 [[package]]
 name = "regex-syntax"
 version = "0.6.28"
@@ -3294,15 +3305,15 @@ checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.2"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "436b050e76ed2903236f032a59761c1eb99e1b0aead2c257922771dab1fc8c78"
+checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
 
 [[package]]
 name = "reqwest"
-version = "0.11.18"
+version = "0.11.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde824a14b7c14f85caff81225f411faacc04a2013f41670f41443742b1c1c55"
+checksum = "3e9ad3fe7488d7e34558a2033d45a0c90b72d97b4f80705666fea71472e2e6a1"
 dependencies = [
  "base64 0.21.0",
  "bytes",
@@ -3332,7 +3343,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "winreg",
+ "winreg 0.50.0",
 ]
 
 [[package]]
@@ -3438,7 +3449,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "549b9d036d571d42e6e85d1c1425e2ac83491075078ca9a15be021c56b1641f2"
 dependencies = [
- "bitflags 2.0.2",
+ "bitflags 2.4.0",
  "fallible-iterator",
  "fallible-streaming-iterator",
  "hashlink",
@@ -3489,13 +3500,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4fdebc4b395b7fbb9ab11e462e20ed9051e7b16e42d24042c776eca0ac81b03"
 dependencies = [
  "bitflags 1.3.2",
- "errno",
+ "errno 0.2.8",
  "io-lifetimes",
  "libc",
- "linux-raw-sys",
+ "linux-raw-sys 0.1.4",
  "windows-sys 0.42.0",
 ]
 
+[[package]]
+name = "rustix"
+version = "0.38.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "747c788e9ce8e92b12cd485c49ddf90723550b654b32508f979b71a7b1ecda4f"
+dependencies = [
+ "bitflags 2.4.0",
+ "errno 0.3.3",
+ "libc",
+ "linux-raw-sys 0.4.7",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "rustls"
 version = "0.20.8"
@@ -3557,9 +3581,9 @@ dependencies = [
 
 [[package]]
 name = "sanitize-filename"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c502bdb638f1396509467cb0580ef3b29aa2a45c5d43e5d84928241280296c"
+checksum = "2ed72fbaf78e6f2d41744923916966c4fbe3d7c74e3037a8ee482f1115572603"
 dependencies = [
  "lazy_static",
  "regex",
@@ -3855,6 +3879,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "socket2"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e"
+dependencies = [
+ "libc",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"
@@ -3919,12 +3953,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
-
 [[package]]
 name = "stop-token"
 version = "0.7.0"
@@ -3945,21 +3973,21 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "strum"
-version = "0.24.1"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
 
 [[package]]
 name = "strum_macros"
-version = "0.24.3"
+version = "0.25.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+checksum = "ad8d03b598d3d0fff69bf533ee3ef19b8eeb342729596df84bcc7e1f96ec4059"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 1.0.107",
+ "syn 2.0.15",
 ]
 
 [[package]]
@@ -4038,7 +4066,7 @@ dependencies = [
  "cfg-if",
  "fastrand",
  "redox_syscall",
- "rustix",
+ "rustix 0.36.7",
  "windows-sys 0.42.0",
 ]
 
@@ -4147,22 +4175,21 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
 
 [[package]]
 name = "tokio"
-version = "1.25.0"
+version = "1.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e00990ebabbe4c14c08aca901caed183ecd5c09562a12c824bb53d3c3fd3af"
+checksum = "17ed6077ed6cd6c74735e21f37eb16dc3935f96878b1fe961074089cc80893f9"
 dependencies = [
- "autocfg",
+ "backtrace",
  "bytes",
  "libc",
- "memchr",
  "mio",
  "num_cpus",
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2",
+ "socket2 0.5.4",
  "tokio-macros",
- "windows-sys 0.42.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -4177,13 +4204,13 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "1.8.2"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d266c00fde287f55d3f1c3e96c500c362a2b8c695076ec180f27918820bc6df8"
+checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.15",
 ]
 
 [[package]]
@@ -4239,9 +4266,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d"
+checksum = "1d68074620f57a0b21594d9735eb2e98ab38b17f80d3fcb189fca266771ca60d"
 dependencies = [
  "bytes",
  "futures-core",
@@ -4365,9 +4392,9 @@ dependencies = [
 
 [[package]]
 name = "trust-dns-proto"
-version = "0.22.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f7f83d1e4a0e4358ac54c5c3681e5d7da5efc5a7a632c90bb6d6669ddd9bc26"
+checksum = "0dc775440033cb114085f6f2437682b194fa7546466024b1037e82a48a052a69"
 dependencies = [
  "async-trait",
  "cfg-if",
@@ -4376,9 +4403,9 @@ dependencies = [
  "futures-channel",
  "futures-io",
  "futures-util",
- "idna 0.2.3",
+ "idna",
  "ipnet",
- "lazy_static",
+ "once_cell",
  "rand 0.8.5",
  "smallvec",
  "thiserror",
@@ -4390,16 +4417,17 @@ dependencies = [
 
 [[package]]
 name = "trust-dns-resolver"
-version = "0.22.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aff21aa4dcefb0a1afbfac26deb0adc93888c7d295fb63ab273ef276ba2b7cfe"
+checksum = "2dff7aed33ef3e8bf2c9966fccdfed93f93d46f432282ea875cd66faabc6ef2f"
 dependencies = [
  "cfg-if",
  "futures-util",
  "ipconfig",
- "lazy_static",
  "lru-cache",
+ "once_cell",
  "parking_lot",
+ "rand 0.8.5",
  "resolv-conf",
  "smallvec",
  "thiserror",
@@ -4431,9 +4459,9 @@ checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.8"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"
+checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
 
 [[package]]
 name = "unicode-ident"
@@ -4480,12 +4508,12 @@ checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 
 [[package]]
 name = "url"
-version = "2.3.1"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5"
 dependencies = [
  "form_urlencoded",
- "idna 0.3.0",
+ "idna",
  "percent-encoding",
 ]
 
@@ -4648,9 +4676,9 @@ dependencies = [
 
 [[package]]
 name = "webpki"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+checksum = "07ecc0cd7cac091bf682ec5efa18b1cff79d617b84181f38b3951dbe135f607f"
 dependencies = [
  "ring",
  "untrusted",
@@ -4731,21 +4759,51 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
 dependencies = [
- "windows_aarch64_gnullvm",
+ "windows_aarch64_gnullvm 0.42.0",
  "windows_aarch64_msvc 0.42.0",
  "windows_i686_gnu 0.42.0",
  "windows_i686_msvc 0.42.0",
  "windows_x86_64_gnu 0.42.0",
- "windows_x86_64_gnullvm",
+ "windows_x86_64_gnullvm 0.42.0",
  "windows_x86_64_msvc 0.42.0",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.32.0"
@@ -4764,6 +4822,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.32.0"
@@ -4782,6 +4846,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.32.0"
@@ -4800,6 +4870,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.32.0"
@@ -4818,12 +4894,24 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.32.0"
@@ -4842,6 +4930,12 @@ version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "winreg"
 version = "0.10.1"
@@ -4851,6 +4945,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "x25519-dalek"
 version = "2.0.0-pre.1"

node/constants.js

@@ -90,6 +90,7 @@ module.exports = {
   DC_KEY_GEN_DEFAULT: 0,
   DC_KEY_GEN_ED25519: 2,
   DC_KEY_GEN_RSA2048: 1,
+  DC_KEY_GEN_RSA4096: 3,
   DC_LP_AUTH_NORMAL: 4,
   DC_LP_AUTH_OAUTH2: 2,
   DC_MEDIA_QUALITY_BALANCED: 0,

node/lib/constants.ts

@@ -90,6 +90,7 @@ export enum C {
   DC_KEY_GEN_DEFAULT = 0,
   DC_KEY_GEN_ED25519 = 2,
   DC_KEY_GEN_RSA2048 = 1,
+  DC_KEY_GEN_RSA4096 = 3,
   DC_LP_AUTH_NORMAL = 4,
   DC_LP_AUTH_OAUTH2 = 2,
   DC_MEDIA_QUALITY_BALANCED = 0,

node/lib/context.ts

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

node/test/test.js

@@ -270,7 +270,7 @@ describe('Basic offline Tests', function () {
       'quota_exceeding',
       'scan_all_folders_debounce_secs',
       'selfavatar',
-      'send_sync_msgs',
+      'sync_msgs',
       'sentbox_watch',
       'show_emails',
       'socks5_enabled',

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.119.0"
+  "version": "1.127.0"
 }

python/mypy.ini

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

python/pyproject.toml

@@ -34,6 +34,7 @@ dynamic = [
 "Home" = "https://github.com/deltachat/deltachat-core-rust/"
 "Bug Tracker" = "https://github.com/deltachat/deltachat-core-rust/issues"
 "Documentation" = "https://py.delta.chat/"
+"Mastodon" = "https://chaos.social/@delta"
 
 [project.entry-points.pytest11]
 "deltachat.testplugin" = "deltachat.testplugin"

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, public: str, secret: str) -> None:
+    def _preconfigure_keypair(self, addr: 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),
-            as_dc_charpointer(public),
+            ffi.NULL,
             as_dc_charpointer(secret),
         )
         if res == 0:
@@ -427,7 +427,7 @@ class Account:
 
         assert dc_chatlist != ffi.NULL
         chatlist = []
-        for i in range(0, lib.dc_chatlist_get_cnt(dc_chatlist)):
+        for i in range(lib.dc_chatlist_get_cnt(dc_chatlist)):
             chat_id = lib.dc_chatlist_get_chat_id(dc_chatlist, i)
             chatlist.append(Chat(self, chat_id))
         return chatlist
@@ -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):
-        from .events import FFIEventLogger
-
+    def run_account(self, addr=None, password=None, account_plugins=None, show_ffi=False, displayname=None):
         """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,6 +644,8 @@ 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,9 +75,12 @@ class Contact:
         """Return True if the contact is verified."""
         return lib.dc_contact_is_verified(self._dc_contact) == 2
 
-    def get_verifier(self, contact):
+    def get_verifier(self, contact) -> Optional["Contact"]:
         """Return the address of the contact that verified the contact."""
-        return from_dc_charpointer(lib.dc_contact_get_verifier_addr(contact._dc_contact))
+        verifier_id = lib.dc_contact_get_verifier_id(contact._dc_contact)
+        if verifier_id == 0:
+            return None
+        return Contact(self.account, verifier_id)
 
     def get_profile_image(self) -> Optional[str]:
         """Get contact profile image.

python/src/deltachat/cutil.py

@@ -15,7 +15,7 @@ def as_dc_charpointer(obj):
 
 
 def iter_array(dc_array_t, constructor: Callable[[int], T]) -> Generator[T, None, None]:
-    for i in range(0, lib.dc_array_get_cnt(dc_array_t)):
+    for i in range(lib.dc_array_get_cnt(dc_array_t)):
         yield constructor(lib.dc_array_get_id(dc_array_t, i))
 
 

python/src/deltachat/testplugin.py

@@ -478,10 +478,9 @@ 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_pub and fname_sec:
-                account._preconfigure_keypair(addr, fname_pub, fname_sec)
+            if fname_sec:
+                account._preconfigure_keypair(addr, fname_sec)
                 return True
             print(f"WARN: could not use preconfigured keys for {addr!r}")
 

python/tests/bench_test_setup.py

@@ -15,6 +15,6 @@ class TestEmpty:
     def test_prepare_setup_measurings(self, acfactory):
         acfactory.get_online_accounts(BENCH_NUM)
 
-    @pytest.mark.parametrize("num", range(0, BENCH_NUM + 1))
+    @pytest.mark.parametrize("num", range(BENCH_NUM + 1))
     def test_setup_online_accounts(self, acfactory, num):
         acfactory.get_online_accounts(num)

python/tests/test_0_complex_or_slow.py

@@ -1,6 +1,7 @@
 import sys
 
 import pytest
+import deltachat as dc
 
 
 class TestGroupStressTests:
@@ -136,6 +137,7 @@ def test_qr_verified_group_and_chatting(acfactory, lp):
     lp.sec("ac2: read member added message")
     msg = ac2._evtracker.wait_next_incoming_message()
     assert msg.is_encrypted()
+    assert msg.is_system_message()
     assert "added" in msg.text.lower()
 
     lp.sec("ac1: send message")
@@ -149,9 +151,8 @@ 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) == ac1_addr
+    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact).id == dc.const.DC_CONTACT_ID_SELF
 
     lp.sec("ac2: send message and let ac1 read it")
     chat2.send_text("world")
@@ -176,14 +177,15 @@ 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) == ac1_addr
+    assert ac2.get_self_contact().get_verifier(ac2_ac1_contact).id == dc.const.DC_CONTACT_ID_SELF
     ac2_ac3_contact = ac2.get_contacts()[1]
-    assert ac2.get_self_contact().get_verifier(ac2_ac3_contact) == ac1_addr
+    assert ac2.get_self_contact().get_verifier(ac2_ac3_contact).addr == ac1_addr
 
     lp.sec("ac2: send message and let ac3 read it")
     chat2.send_text("hi")
-    # Skip system message about added member
-    ac3._evtracker.wait_next_incoming_message()
+    # System message about the added member.
+    msg = ac3._evtracker.wait_next_incoming_message()
+    assert msg.is_system_message()
     msg = ac3._evtracker.wait_next_incoming_message()
     assert msg.text == "hi"
     assert msg.is_encrypted()
@@ -524,7 +526,8 @@ def test_see_new_verified_member_after_going_online(acfactory, tmp_path, lp):
     lp.sec("ac2: sending message")
     # Message can be sent only after a receipt of "vg-member-added" message. Just wait for
     # "Member Me (<addr>) added by <addr>." message.
-    ac2._evtracker.wait_next_incoming_message()
+    msg_in = ac2._evtracker.wait_next_incoming_message()
+    assert msg_in.is_system_message()
     msg_out = chat2.send_text("hello")
 
     lp.sec("ac1: receiving message")
@@ -539,8 +542,6 @@ 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:
@@ -589,4 +590,67 @@ 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
 
-    ac2.set_config("bcc_self", "0")
+
+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("[The message was sent with non-verified encryption")
+    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()

python/tests/test_1_online.py

@@ -9,7 +9,7 @@ import pytest
 from imap_tools import AND, U
 
 import deltachat as dc
-from deltachat import account_hookimpl, Message
+from deltachat import account_hookimpl, Message, Chat
 from deltachat.tracker import ImexTracker
 
 
@@ -1669,8 +1669,12 @@ def test_qr_setup_contact(acfactory, lp):
     ac1._evtracker.wait_securejoin_inviter_progress(1000)
 
 
-def test_qr_join_chat(acfactory, lp):
+@pytest.mark.parametrize("verified_one_on_one_chats", [0, 1])
+def test_qr_join_chat(acfactory, lp, verified_one_on_one_chats):
     ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1.set_config("verified_one_on_one_chats", verified_one_on_one_chats)
+    ac2.set_config("verified_one_on_one_chats", verified_one_on_one_chats)
+
     lp.sec("ac1: create QR code and let ac2 scan it, starting the securejoin")
     chat = ac1.create_group_chat("hello")
     qr = chat.get_join_qr()
@@ -1683,6 +1687,45 @@ def test_qr_join_chat(acfactory, lp):
     ac2._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
     ac1._evtracker.wait_securejoin_inviter_progress(1000)
 
+    msg = ac2._evtracker.wait_next_incoming_message()
+    assert msg.text == "Member Me ({}) added by {}.".format(ac2.get_config("addr"), ac1.get_config("addr"))
+
+    # ac1 reloads the chat.
+    chat = Chat(chat.account, chat.id)
+    assert not chat.is_protected()
+
+    # ac2 reloads the chat.
+    ch = Chat(ch.account, ch.id)
+    assert not ch.is_protected()
+
+
+def test_qr_new_group_unblocked(acfactory, lp):
+    """Regression test for a bug intoduced in core v1.113.0.
+    ac2 scans a verified group QR code created by ac1.
+    This results in creation of a blocked 1:1 chat with ac1 on ac2,
+    but ac1 contact is not blocked on ac2.
+    Then ac1 creates a group, adds ac2 there and promotes it by sending a message.
+    ac2 should receive a message and create a contact request for the group.
+    Due to a bug previously ac2 created a blocked group.
+    """
+
+    ac1, ac2 = acfactory.get_online_accounts(2)
+    ac1_chat = ac1.create_group_chat("Group for joining", verified=True)
+    qr = ac1_chat.get_join_qr()
+    ac2.qr_join_chat(qr)
+
+    ac1._evtracker.wait_securejoin_inviter_progress(1000)
+
+    ac1_new_chat = ac1.create_group_chat("Another group")
+    ac1_new_chat.add_contact(ac2)
+    # Receive "Member added" message.
+    ac2._evtracker.wait_next_incoming_message()
+
+    ac1_new_chat.send_text("Hello!")
+    ac2_msg = ac2._evtracker.wait_next_incoming_message()
+    assert ac2_msg.text == "Hello!"
+    assert ac2_msg.chat.is_contact_request()
+
 
 def test_qr_email_capitalization(acfactory, lp):
     """Regression test for a bug
@@ -1901,13 +1944,15 @@ 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,10 +67,9 @@ 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_public and alice_secret
-        ac._preconfigure_keypair("alice@example.org", alice_public, alice_secret)
+        assert alice_secret
+        ac._preconfigure_keypair("alice@example.org", alice_secret)
 
     def test_getinfo(self, acfactory):
         ac1 = acfactory.get_unconfigured_account()

python/tests/test_4_lowlevel.py

@@ -1,3 +1,4 @@
+import json
 from queue import Queue
 
 import deltachat as dc
@@ -227,10 +228,26 @@ def test_jsonrpc_blocking_call(tmp_path):
         lib.dc_accounts_unref,
     )
     jsonrpc = ffi.gc(lib.dc_jsonrpc_init(accounts), lib.dc_jsonrpc_unref)
-    res = from_optional_dc_charpointer(
-        lib.dc_jsonrpc_blocking_call(jsonrpc, b"check_email_validity", b'["alice@example.org"]'),
+    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"),
+            ),
+        ),
     )
-    assert res == "true"
+    assert res == {"jsonrpc": "2.0", "id": "123", "result": True}
 
-    res = from_optional_dc_charpointer(lib.dc_jsonrpc_blocking_call(jsonrpc, b"check_email_validity", b'["alice"]'))
-    assert res == "false"
+    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}

python/tox.ini

@@ -25,6 +25,9 @@ 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 =
@@ -59,7 +62,8 @@ commands =
 [testenv:doc]
 changedir=doc
 deps =
-    sphinx
+# Pinned due to incompatibility of breathe with sphinx 7.2: <https://github.com/breathe-doc/breathe/issues/943>
+    sphinx<=7.1.2
     breathe
 commands =
     sphinx-build -Q -w toxdoc-warnings.log -b html . _build/html

release-date.in

@@ -1 +1 @@
-2023-08-03
+2023-10-26

scripts/README.md

@@ -10,6 +10,8 @@ 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
@@ -18,7 +20,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 or updates local python test development environment.
+- `make-python-testenv.sh` creates 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/concourse/docs_wheels.yml

@@ -3,14 +3,14 @@ resources:
     type: git
     icon: github
     source:
-      branch: master
+      branch: main
       uri: https://github.com/deltachat/deltachat-core-rust.git
 
   - name: deltachat-core-rust-release
     type: git
     icon: github
     source:
-      branch: master
+      branch: main
       uri: https://github.com/deltachat/deltachat-core-rust.git
       tag_filter: "v*"
 

scripts/coredeps/Dockerfile

@@ -6,3 +6,4 @@ FROM $BASEIMAGE
 RUN pipx install tox
 COPY install-rust.sh /scripts/
 RUN /scripts/install-rust.sh
+RUN if command -v yum; then yum install -y perl-IPC-Cmd; fi

scripts/coredeps/install-rust.sh

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

scripts/create-provider-data-rs.py

@@ -44,7 +44,7 @@ def file2url(f):
 
 def process_opt(data):
     if not "opt" in data:
-        return "Default::default()"
+        return "ProviderOptions::new()"
     opt = "ProviderOptions {\n"
     opt_data = data.get("opt", "")
     for key in opt_data:
@@ -54,7 +54,7 @@ def process_opt(data):
         if value in {"True", "False"}:
             value = value.lower()
         opt += "        " + key + ": " + value + ",\n"
-    opt += "        ..Default::default()\n"
+    opt += "        ..ProviderOptions::new()\n"
     opt += "    }"
     return opt
 
@@ -62,7 +62,7 @@ def process_opt(data):
 def process_config_defaults(data):
     if not "config_defaults" in data:
         return "None"
-    defaults = "Some(vec![\n"
+    defaults = "Some(&[\n"
     config_defaults = data.get("config_defaults", "")
     for key in config_defaults:
         value = str(config_defaults[key])
@@ -96,11 +96,11 @@ def process_data(data, file):
             raise TypeError("domain used twice: " + domain)
         domains_set.add(domain)
 
-        domains += '    ("' + domain + '", &*' + file2varname(file) + "),\n"
+        domains += '    ("' + domain + '", &' + file2varname(file) + "),\n"
         comment += domain + ", "
 
     ids = ""
-    ids += '    ("' + file2id(file) + '", &*' + file2varname(file) + "),\n"
+    ids += '    ("' + file2id(file) + '", &' + file2varname(file) + "),\n"
 
     server = ""
     has_imap = False
@@ -155,18 +155,18 @@ def process_data(data, file):
         provider += (
             "static "
             + file2varname(file)
-            + ": Lazy<Provider> = Lazy::new(|| Provider {\n"
+            + ": Provider = Provider {\n"
         )
         provider += '    id: "' + file2id(file) + '",\n'
         provider += "    status: Status::" + status.capitalize() + ",\n"
         provider += '    before_login_hint: "' + before_login_hint + '",\n'
         provider += '    after_login_hint: "' + after_login_hint + '",\n'
         provider += '    overview_page: "' + file2url(file) + '",\n'
-        provider += "    server: vec![\n" + server + "    ],\n"
+        provider += "    server: &[\n" + server + "    ],\n"
         provider += "    opt: " + opt + ",\n"
         provider += "    config_defaults: " + config_defaults + ",\n"
         provider += "    oauth2_authorizer: " + oauth2 + ",\n"
-        provider += "});\n\n"
+        provider += "};\n\n"
     else:
         raise TypeError("SMTP and IMAP must be specified together or left out both")
 

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 `env/bin/pytest python/`
-# or activate the environment with `. env/bin/activacte`
+# run `pytest` directly with `venv/bin/pytest python/`
+# or activate the environment with `. venv/bin/activate`
 # and run `pytest` from there.
 set -euo pipefail
 
@@ -13,9 +13,5 @@ export DCC_RS_TARGET=debug
 export DCC_RS_DEV="$PWD"
 cargo build -p deltachat_ffi --features jsonrpc
 
-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
+tox -c python -e py --devenv venv
+venv/bin/pip install --upgrade pip

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,pypy37,pypy38,pypy39 --skip-missing-interpreters true
+tox --workdir "$TOXWORKDIR" -e py37,py38,py39,py310,py311,py312,pypy37,pypy38,pypy39,pypy310 --skip-missing-interpreters true
 
 auditwheel repair "$TOXWORKDIR"/wheelhouse/deltachat* -w "$TOXWORKDIR/wheelhouse"
 

scripts/wheel-rpc-server.py

@@ -0,0 +1,197 @@
+#!/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,10 +1,20 @@
 #!/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":
@@ -24,8 +34,23 @@ 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(
-        ["zig", "cc", "-target", zig_target, *zig_cpu_args, *args], check=True
+        [
+            sys.executable,
+            "-m",
+            "ziglang",
+            "cc",
+            "-target",
+            zig_target,
+            *zig_cpu_args,
+            *args,
+        ],
+        check=True,
     )
 
 

scripts/zig-musl-check.sh

@@ -1,28 +0,0 @@
-#!/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.71.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

@@ -8,15 +8,7 @@ set -e
 unset RUSTFLAGS
 
 # Pin Rust version to avoid uncontrolled changes in the compiler and linker flags.
-export RUSTUP_TOOLCHAIN=1.71.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"
+export RUSTUP_TOOLCHAIN=1.72.0
 
 rustup target add i686-unknown-linux-musl
 CC="$PWD/scripts/zig-cc" \
@@ -50,3 +42,9 @@ 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 `mulipart/alternative` containing `text/plain`.
+or `multipart/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/accounts.rs

@@ -1,6 +1,7 @@
 //! # Account manager module.
 
 use std::collections::BTreeMap;
+use std::future::Future;
 use std::path::{Path, PathBuf};
 
 use anyhow::{ensure, Context as _, Result};
@@ -155,7 +156,7 @@ impl Accounts {
         if let Some(cfg) = self.config.get_account(id) {
             let account_path = self.dir.join(cfg.dir);
 
-            fs::remove_dir_all(&account_path)
+            try_many_times(|| fs::remove_dir_all(&account_path))
                 .await
                 .context("failed to remove account data")?;
         }
@@ -191,10 +192,10 @@ impl Accounts {
             fs::create_dir_all(self.dir.join(&account_config.dir))
                 .await
                 .context("failed to create dir")?;
-            fs::rename(&dbfile, &new_dbfile)
+            try_many_times(|| fs::rename(&dbfile, &new_dbfile))
                 .await
                 .context("failed to rename dbfile")?;
-            fs::rename(&blobdir, &new_blobdir)
+            try_many_times(|| fs::rename(&blobdir, &new_blobdir))
                 .await
                 .context("failed to rename blobdir")?;
             if walfile.exists() {
@@ -219,7 +220,7 @@ impl Accounts {
             }
             Err(err) => {
                 let account_path = std::path::PathBuf::from(&account_config.dir);
-                fs::remove_dir_all(&account_path)
+                try_many_times(|| fs::remove_dir_all(&account_path))
                     .await
                     .context("failed to remove account data")?;
                 self.config.remove_account(account_config.id).await?;
@@ -299,13 +300,13 @@ impl Accounts {
 }
 
 /// Configuration file name.
-pub const CONFIG_NAME: &str = "accounts.toml";
+const CONFIG_NAME: &str = "accounts.toml";
 
 /// Lockfile name.
-pub const LOCKFILE_NAME: &str = "accounts.lock";
+const LOCKFILE_NAME: &str = "accounts.lock";
 
 /// Database file name.
-pub const DB_NAME: &str = "dc.db";
+const DB_NAME: &str = "dc.db";
 
 /// Account manager configuration file.
 #[derive(Debug)]
@@ -560,6 +561,37 @@ impl Config {
     }
 }
 
+/// Spend up to 1 minute trying to do the operation.
+///
+/// Even if Delta Chat itself does not hold the file lock,
+/// there may be other processes such as antivirus,
+/// or the filesystem may be network-mounted.
+///
+/// Without this workaround removing account may fail on Windows with an error
+/// "The process cannot access the file because it is being used by another process. (os error 32)".
+async fn try_many_times<F, Fut, T>(f: F) -> std::result::Result<(), T>
+where
+    F: Fn() -> Fut,
+    Fut: Future<Output = std::result::Result<(), T>>,
+{
+    let mut counter = 0;
+    loop {
+        counter += 1;
+
+        if let Err(err) = f().await {
+            if counter > 60 {
+                return Err(err);
+            }
+
+            // Wait 1 second and try again.
+            tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
+        } else {
+            break;
+        }
+    }
+    Ok(())
+}
+
 /// Configuration of a single account.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 struct AccountConfig {

src/blob.rs

@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 
 use anyhow::{format_err, Context as _, Result};
 use futures::StreamExt;
-use image::{DynamicImage, ImageFormat, ImageOutputFormat};
+use image::{DynamicImage, GenericImageView, ImageFormat, ImageOutputFormat};
 use num_traits::FromPrimitive;
 use tokio::io::AsyncWriteExt;
 use tokio::{fs, io};
@@ -323,18 +323,35 @@ impl<'a> BlobObject<'a> {
                 MediaQuality::Worse => constants::WORSE_AVATAR_SIZE,
             };
 
+        let maybe_sticker = &mut false;
         let strict_limits = true;
         // max_bytes is 20_000 bytes: Outlook servers don't allow headers larger than 32k.
         // 32 / 4 * 3 = 24k if you account for base64 encoding. To be safe, we reduced this to 20k.
-        if let Some(new_name) =
-            self.recode_to_size(context, blob_abs, img_wh, 20_000, strict_limits)?
-        {
+        if let Some(new_name) = self.recode_to_size(
+            context,
+            blob_abs,
+            maybe_sticker,
+            img_wh,
+            20_000,
+            strict_limits,
+        )? {
             self.name = new_name;
         }
         Ok(())
     }
 
-    pub async fn recode_to_image_size(&mut self, context: &Context) -> Result<()> {
+    /// Recodes an image pointed by a [BlobObject] so that it fits into limits on the image width,
+    /// height and file size specified by the config.
+    ///
+    /// On some platforms images are passed to the core as [`crate::message::Viewtype::Sticker`] in
+    /// which case `maybe_sticker` flag should be set. We recheck if an image is a true sticker
+    /// assuming that it must have at least one fully transparent corner, otherwise this flag is
+    /// reset.
+    pub async fn recode_to_image_size(
+        &mut self,
+        context: &Context,
+        maybe_sticker: &mut bool,
+    ) -> Result<()> {
         let blob_abs = self.to_abs_path();
         let (img_wh, max_bytes) =
             match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
@@ -347,9 +364,14 @@ impl<'a> BlobObject<'a> {
                 MediaQuality::Worse => (constants::WORSE_IMAGE_SIZE, constants::WORSE_IMAGE_BYTES),
             };
         let strict_limits = false;
-        if let Some(new_name) =
-            self.recode_to_size(context, blob_abs, img_wh, max_bytes, strict_limits)?
-        {
+        if let Some(new_name) = self.recode_to_size(
+            context,
+            blob_abs,
+            maybe_sticker,
+            img_wh,
+            max_bytes,
+            strict_limits,
+        )? {
             self.name = new_name;
         }
         Ok(())
@@ -358,20 +380,37 @@ impl<'a> BlobObject<'a> {
     /// If `!strict_limits`, then if `max_bytes` is exceeded, reduce the image to `img_wh` and just
     /// proceed with the result.
     fn recode_to_size(
-        &self,
+        &mut self,
         context: &Context,
         mut blob_abs: PathBuf,
+        maybe_sticker: &mut bool,
         mut img_wh: u32,
         max_bytes: usize,
         strict_limits: bool,
     ) -> Result<Option<String>> {
-        tokio::task::block_in_place(move || {
-            let mut img = image::open(&blob_abs).context("image decode failure")?;
+        let mut no_exif = false;
+        let no_exif_ref = &mut no_exif;
+        let res = tokio::task::block_in_place(move || {
             let (nr_bytes, exif) = self.metadata()?;
+            *no_exif_ref = exif.is_none();
+            let mut img = image::open(&blob_abs).context("image decode failure")?;
             let orientation = exif.as_ref().map(|exif| exif_orientation(exif, context));
             let mut encoded = Vec::new();
             let mut changed_name = None;
 
+            if *maybe_sticker {
+                let x_max = img.width().saturating_sub(1);
+                let y_max = img.height().saturating_sub(1);
+                *maybe_sticker = img.in_bounds(x_max, y_max)
+                    && (img.get_pixel(0, 0).0[3] == 0
+                        || img.get_pixel(x_max, 0).0[3] == 0
+                        || img.get_pixel(0, y_max).0[3] == 0
+                        || img.get_pixel(x_max, y_max).0[3] == 0);
+            }
+            if *maybe_sticker && exif.is_none() {
+                return Ok(None);
+            }
+
             img = match orientation {
                 Some(90) => img.rotate90(),
                 Some(180) => img.rotate180(),
@@ -469,7 +508,21 @@ impl<'a> BlobObject<'a> {
             }
 
             Ok(changed_name)
-        })
+        });
+        match res {
+            Ok(_) => res,
+            Err(err) => {
+                if !strict_limits && no_exif {
+                    warn!(
+                        context,
+                        "Cannot recode image, using original data: {err:#}.",
+                    );
+                    Ok(None)
+                } else {
+                    Err(err)
+                }
+            }
+        }
     }
 
     /// Returns image file size and Exif.
@@ -860,10 +913,18 @@ mod tests {
             file.metadata().await.unwrap().len()
         }
 
-        let blob = BlobObject::new_from_path(&t, &avatar_blob).await.unwrap();
+        let mut blob = BlobObject::new_from_path(&t, &avatar_blob).await.unwrap();
+        let maybe_sticker = &mut false;
         let strict_limits = true;
-        blob.recode_to_size(&t, blob.to_abs_path(), 1000, 3000, strict_limits)
-            .unwrap();
+        blob.recode_to_size(
+            &t,
+            blob.to_abs_path(),
+            maybe_sticker,
+            1000,
+            3000,
+            strict_limits,
+        )
+        .unwrap();
         assert!(file_size(&avatar_blob).await <= 3000);
         assert!(file_size(&avatar_blob).await > 2000);
         tokio::task::block_in_place(move || {
@@ -923,6 +984,7 @@ mod tests {
     async fn test_recode_image_1() {
         let bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
         send_image_check_mediaquality(
+            Viewtype::Image,
             Some("0"),
             bytes,
             "jpg",
@@ -936,6 +998,7 @@ mod tests {
         .await
         .unwrap();
         send_image_check_mediaquality(
+            Viewtype::Image,
             Some("1"),
             bytes,
             "jpg",
@@ -955,6 +1018,7 @@ mod tests {
         // The "-rotated" files are rotated by 270 degrees using the Exif metadata
         let bytes = include_bytes!("../test-data/image/rectangle2000x1800-rotated.jpg");
         let img_rotated = send_image_check_mediaquality(
+            Viewtype::Image,
             Some("0"),
             bytes,
             "jpg",
@@ -974,6 +1038,7 @@ mod tests {
         let bytes = buf.into_inner();
 
         let img_rotated = send_image_check_mediaquality(
+            Viewtype::Image,
             Some("1"),
             &bytes,
             "jpg",
@@ -994,6 +1059,7 @@ mod tests {
         let bytes = include_bytes!("../test-data/image/screenshot.png");
 
         send_image_check_mediaquality(
+            Viewtype::Image,
             Some("0"),
             bytes,
             "png",
@@ -1008,6 +1074,7 @@ mod tests {
         .unwrap();
 
         send_image_check_mediaquality(
+            Viewtype::Image,
             Some("1"),
             bytes,
             "png",
@@ -1020,12 +1087,29 @@ mod tests {
         )
         .await
         .unwrap();
+
+        // This will be sent as Image, see [`BlobObject::maybe_sticker`] for explanation.
+        send_image_check_mediaquality(
+            Viewtype::Sticker,
+            Some("0"),
+            bytes,
+            "png",
+            false, // no Exif
+            1920,
+            1080,
+            0,
+            1920,
+            1080,
+        )
+        .await
+        .unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_recode_image_huge_jpg() {
         let bytes = include_bytes!("../test-data/image/screenshot.jpg");
         send_image_check_mediaquality(
+            Viewtype::Image,
             Some("0"),
             bytes,
             "jpg",
@@ -1059,6 +1143,7 @@ mod tests {
 
     #[allow(clippy::too_many_arguments)]
     async fn send_image_check_mediaquality(
+        viewtype: Viewtype,
         media_quality_config: Option<&str>,
         bytes: &[u8],
         extension: &str,
@@ -1090,7 +1175,7 @@ mod tests {
             assert!(exif.is_none());
         }
 
-        let mut msg = Message::new(Viewtype::Image);
+        let mut msg = Message::new(viewtype);
         msg.set_file(file.to_str().unwrap(), None);
         let chat = alice.create_chat(&bob).await;
         let sent = alice.send_msg(chat.id, &mut msg).await;
@@ -1104,6 +1189,7 @@ mod tests {
         );
 
         let bob_msg = bob.recv_msg(&sent).await;
+        assert_eq!(bob_msg.get_viewtype(), Viewtype::Image);
         assert_eq!(bob_msg.get_width() as u32, compressed_width);
         assert_eq!(bob_msg.get_height() as u32, compressed_height);
         let file = bob_msg.get_file(&bob).unwrap();

src/chat.rs

@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::aheader::EncryptPreference;
 use crate::blob::BlobObject;
+use crate::chatlist::Chatlist;
 use crate::color::str_to_color;
 use crate::config::Config;
 use crate::constants::{
@@ -22,6 +23,7 @@ use crate::constants::{
 use crate::contact::{Contact, ContactId, Origin, VerifiedStatus};
 use crate::context::Context;
 use crate::debug_logging::maybe_set_logging_xdc;
+use crate::download::DownloadState;
 use crate::ephemeral::Timer as EphemeralTimer;
 use crate::events::EventType;
 use crate::html::new_html_mimepart;
@@ -885,6 +887,134 @@ impl ChatId {
         Ok(count)
     }
 
+    /// Returns timestamp of the latest message in the chat.
+    pub(crate) async fn get_timestamp(self, context: &Context) -> Result<Option<i64>> {
+        let timestamp = context
+            .sql
+            .query_get_value("SELECT MAX(timestamp) FROM msgs WHERE chat_id=?", (self,))
+            .await?;
+        Ok(timestamp)
+    }
+
+    /// Returns a list of active similar chat IDs sorted by similarity metric.
+    ///
+    /// Jaccard similarity coefficient is used to estimate similarity of chat member sets.
+    ///
+    /// Chat is considered active if something was posted there within the last 42 days.
+    pub async fn get_similar_chat_ids(self, context: &Context) -> Result<Vec<(ChatId, f64)>> {
+        // Count number of common members in this and other chats.
+        let intersection: Vec<(ChatId, f64)> = context
+            .sql
+            .query_map(
+                "SELECT y.chat_id, SUM(x.contact_id = y.contact_id)
+                 FROM chats_contacts as x
+                 JOIN chats_contacts as y
+                 WHERE x.contact_id > 9
+                   AND y.contact_id > 9
+                   AND x.chat_id=?
+                   AND y.chat_id<>x.chat_id
+                 GROUP BY y.chat_id",
+                (self,),
+                |row| {
+                    let chat_id: ChatId = row.get(0)?;
+                    let intersection: f64 = row.get(1)?;
+                    Ok((chat_id, intersection))
+                },
+                |rows| {
+                    rows.collect::<std::result::Result<Vec<_>, _>>()
+                        .map_err(Into::into)
+                },
+            )
+            .await
+            .context("failed to calculate member set intersections")?;
+
+        let chat_size: HashMap<ChatId, f64> = context
+            .sql
+            .query_map(
+                "SELECT chat_id, count(*) AS n
+                 FROM chats_contacts
+                 WHERE contact_id > ? AND chat_id > ?
+                 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)?;
+                    Ok((chat_id, size))
+                },
+                |rows| {
+                    rows.collect::<std::result::Result<HashMap<ChatId, f64>, _>>()
+                        .map_err(Into::into)
+                },
+            )
+            .await
+            .context("failed to count chat member sizes")?;
+
+        let our_chat_size = chat_size.get(&self).copied().unwrap_or_default();
+        let mut chats_with_metrics = Vec::new();
+        for (chat_id, intersection_size) in intersection {
+            if intersection_size > 0.0 {
+                let other_chat_size = chat_size.get(&chat_id).copied().unwrap_or_default();
+                let union_size = our_chat_size + other_chat_size - intersection_size;
+                let metric = intersection_size / union_size;
+                chats_with_metrics.push((chat_id, metric))
+            }
+        }
+        chats_with_metrics.sort_unstable_by(|(chat_id1, metric1), (chat_id2, metric2)| {
+            metric2
+                .partial_cmp(metric1)
+                .unwrap_or(chat_id2.cmp(chat_id1))
+        });
+
+        // Select up to five similar active chats.
+        let mut res = Vec::new();
+        let now = time();
+        for (chat_id, metric) in chats_with_metrics {
+            if let Some(chat_timestamp) = chat_id.get_timestamp(context).await? {
+                if now > chat_timestamp + 42 * 24 * 3600 {
+                    // Chat was inactive for 42 days, skip.
+                    continue;
+                }
+            }
+
+            if metric < 0.1 {
+                // Chat is unrelated.
+                break;
+            }
+
+            let chat = Chat::load_from_db(context, chat_id).await?;
+            if chat.typ != Chattype::Group {
+                continue;
+            }
+
+            match chat.visibility {
+                ChatVisibility::Normal | ChatVisibility::Pinned => {}
+                ChatVisibility::Archived => continue,
+            }
+
+            res.push((chat_id, metric));
+            if res.len() >= 5 {
+                break;
+            }
+        }
+
+        Ok(res)
+    }
+
+    /// Returns similar chats as a [`Chatlist`].
+    ///
+    /// [`Chatlist`]: crate::chatlist::Chatlist
+    pub async fn get_similar_chatlist(self, context: &Context) -> Result<Chatlist> {
+        let chat_ids: Vec<ChatId> = self
+            .get_similar_chat_ids(context)
+            .await
+            .context("failed to get similar chat IDs")?
+            .into_iter()
+            .map(|(chat_id, _metric)| chat_id)
+            .collect();
+        let chatlist = Chatlist::from_chat_ids(context, &chat_ids).await?;
+        Ok(chatlist)
+    }
+
     pub(crate) async fn get_param(self, context: &Context) -> Result<Params> {
         let res: Option<String> = context
             .sql
@@ -924,11 +1054,14 @@ impl ChatId {
         T: Send + 'static,
     {
         let sql = &context.sql;
+        // Do not reply to not fully downloaded messages. Such a message could be a group chat
+        // message that we assigned to 1:1 chat.
         let query = format!(
             "SELECT {fields} \
-             FROM msgs WHERE chat_id=? AND state NOT IN (?, ?, ?, ?) AND NOT hidden \
+             FROM msgs WHERE chat_id=? AND state NOT IN (?, ?) AND NOT hidden AND download_state={} \
              ORDER BY timestamp DESC, id DESC \
-             LIMIT 1;"
+             LIMIT 1;",
+             DownloadState::Done as u32,
         );
         let row = sql
             .query_row_optional(
@@ -937,8 +1070,11 @@ impl ChatId {
                     self,
                     MessageState::OutPreparing,
                     MessageState::OutDraft,
-                    MessageState::OutPending,
-                    MessageState::OutFailed,
+                    // We don't filter `OutPending` and `OutFailed` messages because the new message
+                    // for which `parent_query()` is done may assume that it will be received in a
+                    // context affected by those messages, e.g. they could add new members to a
+                    // group and the new message will contain them in "To:". Anyway recipients must
+                    // be prepared to orphaned references.
                 ),
                 f,
             )
@@ -950,34 +1086,17 @@ impl ChatId {
         self,
         context: &Context,
     ) -> Result<Option<(String, String, String)>> {
-        if let Some((rfc724_mid, mime_in_reply_to, mime_references, error)) = self
-            .parent_query(
-                context,
-                "rfc724_mid, mime_in_reply_to, mime_references, error",
-                |row: &rusqlite::Row| {
-                    let rfc724_mid: String = row.get(0)?;
-                    let mime_in_reply_to: String = row.get(1)?;
-                    let mime_references: String = row.get(2)?;
-                    let error: String = row.get(3)?;
-                    Ok((rfc724_mid, mime_in_reply_to, mime_references, error))
-                },
-            )
-            .await?
-        {
-            if !error.is_empty() {
-                // Do not reply to error messages.
-                //
-                // An error message could be a group chat message that we failed to decrypt and
-                // assigned to 1:1 chat. A reply to it will show up as a reply to group message
-                // on the other side. To avoid such situations, it is better not to reply to
-                // error messages at all.
-                Ok(None)
-            } else {
-                Ok(Some((rfc724_mid, mime_in_reply_to, mime_references)))
-            }
-        } else {
-            Ok(None)
-        }
+        self.parent_query(
+            context,
+            "rfc724_mid, mime_in_reply_to, mime_references",
+            |row: &rusqlite::Row| {
+                let rfc724_mid: String = row.get(0)?;
+                let mime_in_reply_to: String = row.get(1)?;
+                let mime_references: String = row.get(2)?;
+                Ok((rfc724_mid, mime_in_reply_to, mime_references))
+            },
+        )
+        .await
     }
 
     /// Returns multi-line text summary of encryption preferences of all chat contacts.
@@ -1255,6 +1374,7 @@ impl Chat {
     pub(crate) async fn why_cant_send(&self, context: &Context) -> Result<Option<CantSendReason>> {
         use CantSendReason::*;
 
+        // NB: Don't forget to update Chatlist::try_load() when changing this function!
         let reason = if self.id.is_special() {
             Some(SpecialChat)
         } else if self.is_device_talk() {
@@ -1263,7 +1383,7 @@ impl Chat {
             Some(ContactRequest)
         } else if self.is_protection_broken() {
             Some(ProtectionBroken)
-        } else if self.is_mailing_list() && self.param.get(Param::ListPost).is_none_or_empty() {
+        } else if self.is_mailing_list() && self.get_mailinglist_addr().is_none_or_empty() {
             Some(ReadOnlyMailingList)
         } else if !self.is_self_in_chat(context).await? {
             Some(NotAMember)
@@ -1325,11 +1445,11 @@ impl Chat {
     pub async fn get_profile_image(&self, context: &Context) -> Result<Option<PathBuf>> {
         if let Some(image_rel) = self.param.get(Param::ProfileImage) {
             if !image_rel.is_empty() {
-                return Ok(Some(get_abs_path(context, image_rel)));
+                return Ok(Some(get_abs_path(context, Path::new(&image_rel))));
             }
         } else if self.id.is_archived_link() {
             if let Ok(image_rel) = get_archive_icon(context).await {
-                return Ok(Some(get_abs_path(context, image_rel)));
+                return Ok(Some(get_abs_path(context, Path::new(&image_rel))));
             }
         } else if self.typ == Chattype::Single {
             let contacts = get_chat_contacts(context, self.id).await?;
@@ -1340,7 +1460,7 @@ impl Chat {
             }
         } else if self.typ == Chattype::Broadcast {
             if let Ok(image_rel) = get_broadcast_icon(context).await {
-                return Ok(Some(get_abs_path(context, image_rel)));
+                return Ok(Some(get_abs_path(context, Path::new(&image_rel))));
             }
         }
         Ok(None)
@@ -1611,6 +1731,11 @@ impl Chat {
             None
         };
 
+        msg.chat_id = self.id;
+        msg.from_id = ContactId::SELF;
+        msg.rfc724_mid = new_rfc724_mid;
+        msg.timestamp_sort = timestamp;
+
         // add message to the database
         if let Some(update_msg_id) = update_msg_id {
             context
@@ -1624,11 +1749,11 @@ impl Chat {
                          ephemeral_timestamp=?
                      WHERE id=?;",
                     params_slice![
-                        new_rfc724_mid,
-                        self.id,
-                        ContactId::SELF,
+                        msg.rfc724_mid,
+                        msg.chat_id,
+                        msg.from_id,
                         to_id,
-                        timestamp,
+                        msg.timestamp_sort,
                         msg.viewtype,
                         msg.state,
                         msg.text,
@@ -1673,11 +1798,11 @@ impl Chat {
                         ephemeral_timestamp)
                         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?,?);",
                     params_slice![
-                        new_rfc724_mid,
-                        self.id,
-                        ContactId::SELF,
+                        msg.rfc724_mid,
+                        msg.chat_id,
+                        msg.from_id,
                         to_id,
-                        timestamp,
+                        msg.timestamp_sort,
                         msg.viewtype,
                         msg.state,
                         msg.text,
@@ -2082,12 +2207,15 @@ async fn prepare_msg_blob(context: &Context, msg: &mut Message) -> Result<()> {
             .await?
             .with_context(|| format!("attachment missing for message of type #{}", msg.viewtype))?;
 
-        if msg.viewtype == Viewtype::Image {
-            if let Err(err) = blob.recode_to_image_size(context).await {
-                warn!(
-                    context,
-                    "Cannot recode image, using original data: {err:#}."
-                );
+        let mut maybe_sticker = msg.viewtype == Viewtype::Sticker;
+        if msg.viewtype == Viewtype::Image
+            || maybe_sticker && !msg.param.exists(Param::ForceSticker)
+        {
+            blob.recode_to_image_size(context, &mut maybe_sticker)
+                .await?;
+
+            if !maybe_sticker {
+                msg.viewtype = Viewtype::Image;
             }
         }
         msg.param.set(Param::File, blob.as_name());
@@ -2134,6 +2262,8 @@ async fn prepare_msg_blob(context: &Context, msg: &mut Message) -> Result<()> {
             }
         }
 
+        msg.try_calc_and_set_dimensions(context).await?;
+
         info!(
             context,
             "Attaching \"{}\" for message type #{}.",
@@ -2307,7 +2437,7 @@ async fn prepare_send_msg(
         );
         message::update_msg_state(context, msg.id, MessageState::OutPending).await?;
     }
-    let row_id = create_send_msg_job(context, msg.id).await?;
+    let row_id = create_send_msg_job(context, msg).await?;
     Ok(row_id)
 }
 
@@ -2317,13 +2447,10 @@ async fn prepare_send_msg(
 /// group with only self and no BCC-to-self configured.
 ///
 /// The caller has to interrupt SMTP loop or otherwise process a new row.
-async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<i64>> {
-    let mut msg = Message::load_from_db(context, msg_id).await?;
-    msg.try_calc_and_set_dimensions(context)
-        .await
-        .context("failed to calculate media dimensions")?;
-
-    /* create message */
+pub(crate) async fn create_send_msg_job(
+    context: &Context,
+    msg: &mut Message,
+) -> Result<Option<i64>> {
     let needs_encryption = msg.param.get_bool(Param::GuaranteeE2ee).unwrap_or_default();
 
     let attach_selfavatar = match shall_attach_selfavatar(context, msg.chat_id).await {
@@ -2334,7 +2461,7 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
         }
     };
 
-    let mimefactory = MimeFactory::from_msg(context, &msg, attach_selfavatar).await?;
+    let mimefactory = MimeFactory::from_msg(context, msg, attach_selfavatar).await?;
 
     let mut recipients = mimefactory.recipients();
 
@@ -2356,16 +2483,17 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
         // may happen eg. for groups with only SELF and bcc_self disabled
         info!(
             context,
-            "Message {msg_id} has no recipient, skipping smtp-send."
+            "Message {} has no recipient, skipping smtp-send.", msg.id
         );
-        msg_id.set_delivered(context).await?;
+        msg.id.set_delivered(context).await?;
+        msg.state = MessageState::OutDelivered;
         return Ok(None);
     }
 
     let rendered_msg = match mimefactory.render(context).await {
         Ok(res) => Ok(res),
         Err(err) => {
-            message::set_msg_failed(context, msg_id, &err.to_string()).await;
+            message::set_msg_failed(context, msg, &err.to_string()).await?;
             Err(err)
         }
     }?;
@@ -2374,13 +2502,13 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
         /* unrecoverable */
         message::set_msg_failed(
             context,
-            msg_id,
+            msg,
             "End-to-end-encryption unavailable unexpectedly.",
         )
-        .await;
+        .await?;
         bail!(
             "e2e encryption unavailable {} - {:?}",
-            msg_id,
+            msg.id,
             needs_encryption
         );
     }
@@ -2435,7 +2563,7 @@ async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<
                 &rendered_msg.rfc724_mid,
                 recipients,
                 &rendered_msg.message,
-                msg_id,
+                msg.id,
             ),
         )
         .await?;
@@ -2628,14 +2756,7 @@ pub(crate) async fn marknoticed_chat_if_older_than(
     chat_id: ChatId,
     timestamp: i64,
 ) -> Result<()> {
-    if let Some(chat_timestamp) = context
-        .sql
-        .query_get_value(
-            "SELECT MAX(timestamp) FROM msgs WHERE chat_id=?",
-            (chat_id,),
-        )
-        .await?
-    {
+    if let Some(chat_timestamp) = chat_id.get_timestamp(context).await? {
         if timestamp > chat_timestamp {
             marknoticed_chat(context, chat_id).await?;
         }
@@ -2834,6 +2955,9 @@ 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,
@@ -3421,89 +3545,88 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
     chat_id
         .unarchive_if_not_muted(context, MessageState::Undefined)
         .await?;
-    if let Ok(mut chat) = Chat::load_from_db(context, chat_id).await {
-        if let Some(reason) = chat.why_cant_send(context).await? {
-            bail!("cannot send to {}: {}", chat_id, reason);
+    let mut chat = Chat::load_from_db(context, chat_id).await?;
+    if let Some(reason) = chat.why_cant_send(context).await? {
+        bail!("cannot send to {}: {}", chat_id, reason);
+    }
+    curr_timestamp = create_smeared_timestamps(context, msg_ids.len());
+    let ids = context
+        .sql
+        .query_map(
+            &format!(
+                "SELECT id FROM msgs WHERE id IN({}) ORDER BY timestamp,id",
+                sql::repeat_vars(msg_ids.len())
+            ),
+            rusqlite::params_from_iter(msg_ids),
+            |row| row.get::<_, MsgId>(0),
+            |ids| ids.collect::<Result<Vec<_>, _>>().map_err(Into::into),
+        )
+        .await?;
+
+    for id in ids {
+        let src_msg_id: MsgId = id;
+        let mut msg = Message::load_from_db(context, src_msg_id).await?;
+        if msg.state == MessageState::OutDraft {
+            bail!("cannot forward drafts.");
         }
-        curr_timestamp = create_smeared_timestamps(context, msg_ids.len());
-        let ids = context
-            .sql
-            .query_map(
-                &format!(
-                    "SELECT id FROM msgs WHERE id IN({}) ORDER BY timestamp,id",
-                    sql::repeat_vars(msg_ids.len())
-                ),
-                rusqlite::params_from_iter(msg_ids),
-                |row| row.get::<_, MsgId>(0),
-                |ids| ids.collect::<Result<Vec<_>, _>>().map_err(Into::into),
-            )
-            .await?;
 
-        for id in ids {
-            let src_msg_id: MsgId = id;
-            let mut msg = Message::load_from_db(context, src_msg_id).await?;
-            if msg.state == MessageState::OutDraft {
-                bail!("cannot forward drafts.");
-            }
+        let original_param = msg.param.clone();
 
-            let original_param = msg.param.clone();
+        // we tested a sort of broadcast
+        // by not marking own forwarded messages as such,
+        // however, this turned out to be to confusing and unclear.
 
-            // we tested a sort of broadcast
-            // by not marking own forwarded messages as such,
-            // however, this turned out to be to confusing and unclear.
+        if msg.get_viewtype() != Viewtype::Sticker {
+            msg.param
+                .set_int(Param::Forwarded, src_msg_id.to_u32() as i32);
+        }
 
-            if msg.get_viewtype() != Viewtype::Sticker {
-                msg.param
-                    .set_int(Param::Forwarded, src_msg_id.to_u32() as i32);
-            }
+        msg.param.remove(Param::GuaranteeE2ee);
+        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;
 
-            msg.param.remove(Param::GuaranteeE2ee);
-            msg.param.remove(Param::ForcePlaintext);
-            msg.param.remove(Param::Cmd);
-            msg.param.remove(Param::OverrideSenderDisplayname);
-            msg.param.remove(Param::WebxdcSummary);
-            msg.param.remove(Param::WebxdcSummaryTimestamp);
-            msg.in_reply_to = None;
+        // do not leak data as group names; a default subject is generated by mimefactory
+        msg.subject = "".to_string();
 
-            // do not leak data as group names; a default subject is generated by mimefactory
-            msg.subject = "".to_string();
+        let new_msg_id: MsgId;
+        if msg.state == MessageState::OutPreparing {
+            new_msg_id = chat
+                .prepare_msg_raw(context, &mut msg, None, curr_timestamp)
+                .await?;
+            curr_timestamp += 1;
+            msg.param = original_param;
+            msg.id = src_msg_id;
 
-            let new_msg_id: MsgId;
-            if msg.state == MessageState::OutPreparing {
-                new_msg_id = chat
-                    .prepare_msg_raw(context, &mut msg, None, curr_timestamp)
-                    .await?;
-                curr_timestamp += 1;
-                let save_param = msg.param.clone();
-                msg.param = original_param;
-                msg.id = src_msg_id;
-
-                if let Some(old_fwd) = msg.param.get(Param::PrepForwards) {
-                    let new_fwd = format!("{} {}", old_fwd, new_msg_id.to_u32());
-                    msg.param.set(Param::PrepForwards, new_fwd);
-                } else {
-                    msg.param
-                        .set(Param::PrepForwards, new_msg_id.to_u32().to_string());
-                }
-
-                msg.update_param(context).await?;
-                msg.param = save_param;
+            if let Some(old_fwd) = msg.param.get(Param::PrepForwards) {
+                let new_fwd = format!("{} {}", old_fwd, new_msg_id.to_u32());
+                msg.param.set(Param::PrepForwards, new_fwd);
             } else {
-                msg.state = MessageState::OutPending;
-                new_msg_id = chat
-                    .prepare_msg_raw(context, &mut msg, None, curr_timestamp)
-                    .await?;
-                curr_timestamp += 1;
-                if create_send_msg_job(context, new_msg_id).await?.is_some() {
-                    context
-                        .scheduler
-                        .interrupt_smtp(InterruptInfo::new(false))
-                        .await;
-                }
+                msg.param
+                    .set(Param::PrepForwards, new_msg_id.to_u32().to_string());
+            }
+
+            msg.update_param(context).await?;
+        } else {
+            msg.state = MessageState::OutPending;
+            new_msg_id = chat
+                .prepare_msg_raw(context, &mut msg, None, curr_timestamp)
+                .await?;
+            curr_timestamp += 1;
+            if create_send_msg_job(context, &mut msg).await?.is_some() {
+                context
+                    .scheduler
+                    .interrupt_smtp(InterruptInfo::new(false))
+                    .await;
             }
-            created_chats.push(chat_id);
-            created_msgs.push(new_msg_id);
         }
+        created_chats.push(chat_id);
+        created_msgs.push(new_msg_id);
     }
     for (chat_id, msg_id) in created_chats.iter().zip(created_msgs.iter()) {
         context.emit_msgs_changed(*chat_id, *msg_id);
@@ -3535,29 +3658,31 @@ pub async fn resend_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
         msgs.push(msg)
     }
 
-    if let Some(chat_id) = chat_id {
-        let chat = Chat::load_from_db(context, chat_id).await?;
-        for mut msg in msgs {
-            if msg.get_showpadlock() && !chat.is_protected() {
-                msg.param.remove(Param::GuaranteeE2ee);
-                msg.update_param(context).await?;
-            }
-            match msg.get_state() {
-                MessageState::OutFailed | MessageState::OutDelivered | MessageState::OutMdnRcvd => {
-                    message::update_msg_state(context, msg.id, MessageState::OutPending).await?
-                }
-                _ => bail!("unexpected message state"),
-            }
-            context.emit_event(EventType::MsgsChanged {
-                chat_id: msg.chat_id,
-                msg_id: msg.id,
-            });
-            if create_send_msg_job(context, msg.id).await?.is_some() {
-                context
-                    .scheduler
-                    .interrupt_smtp(InterruptInfo::new(false))
-                    .await;
+    let Some(chat_id) = chat_id else {
+        return Ok(());
+    };
+
+    let chat = Chat::load_from_db(context, chat_id).await?;
+    for mut msg in msgs {
+        if msg.get_showpadlock() && !chat.is_protected() {
+            msg.param.remove(Param::GuaranteeE2ee);
+            msg.update_param(context).await?;
+        }
+        match msg.get_state() {
+            MessageState::OutFailed | MessageState::OutDelivered | MessageState::OutMdnRcvd => {
+                message::update_msg_state(context, msg.id, MessageState::OutPending).await?
             }
+            _ => bail!("unexpected message state"),
+        }
+        context.emit_event(EventType::MsgsChanged {
+            chat_id: msg.chat_id,
+            msg_id: msg.id,
+        });
+        if create_send_msg_job(context, &mut msg).await?.is_some() {
+            context
+                .scheduler
+                .interrupt_smtp(InterruptInfo::new(false))
+                .await;
         }
     }
     Ok(())
@@ -3627,7 +3752,6 @@ pub async fn add_device_msg_with_importance(
         chat_id = ChatId::get_for_contact(context, ContactId::DEVICE).await?;
 
         let rfc724_mid = create_outgoing_rfc724_mid(None, "@device");
-        msg.try_calc_and_set_dimensions(context).await.ok();
         prepare_msg_blob(context, msg).await?;
 
         let timestamp_sent = create_smeared_timestamp(context);
@@ -5494,7 +5618,13 @@ mod tests {
         Ok(())
     }
 
-    async fn test_sticker(filename: &str, bytes: &[u8], w: i32, h: i32) -> Result<()> {
+    async fn test_sticker(
+        filename: &str,
+        bytes: &[u8],
+        res_viewtype: Viewtype,
+        w: i32,
+        h: i32,
+    ) -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
         let alice_chat = alice.create_chat(&bob).await;
@@ -5508,12 +5638,19 @@ mod tests {
 
         let sent_msg = alice.send_msg(alice_chat.id, &mut msg).await;
         let mime = sent_msg.payload();
-        assert_eq!(mime.match_indices("Chat-Content: sticker").count(), 1);
+        if res_viewtype == Viewtype::Sticker {
+            assert_eq!(mime.match_indices("Chat-Content: sticker").count(), 1);
+        }
 
         let msg = bob.recv_msg(&sent_msg).await;
         assert_eq!(msg.chat_id, bob_chat.id);
-        assert_eq!(msg.get_viewtype(), Viewtype::Sticker);
-        assert_eq!(msg.get_filename().unwrap(), filename);
+        assert_eq!(msg.get_viewtype(), res_viewtype);
+        let msg_filename = msg.get_filename().unwrap();
+        match res_viewtype {
+            Viewtype::Sticker => assert_eq!(msg_filename, filename),
+            Viewtype::Image => assert!(msg_filename.starts_with("image_")),
+            _ => panic!("Not implemented"),
+        }
         assert_eq!(msg.get_width(), w);
         assert_eq!(msg.get_height(), h);
         assert!(msg.get_filebytes(&bob).await?.unwrap() > 250);
@@ -5525,9 +5662,10 @@ mod tests {
     async fn test_sticker_png() -> Result<()> {
         test_sticker(
             "sticker.png",
-            include_bytes!("../test-data/image/avatar64x64.png"),
-            64,
-            64,
+            include_bytes!("../test-data/image/logo.png"),
+            Viewtype::Sticker,
+            135,
+            135,
         )
         .await
     }
@@ -5537,19 +5675,66 @@ mod tests {
         test_sticker(
             "sticker.jpg",
             include_bytes!("../test-data/image/avatar1000x1000.jpg"),
+            Viewtype::Image,
             1000,
             1000,
         )
         .await
     }
 
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_sticker_jpeg_force() {
+        let alice = TestContext::new_alice().await;
+        let bob = TestContext::new_bob().await;
+        let alice_chat = alice.create_chat(&bob).await;
+
+        let file = alice.get_blobdir().join("sticker.jpg");
+        tokio::fs::write(
+            &file,
+            include_bytes!("../test-data/image/avatar1000x1000.jpg"),
+        )
+        .await
+        .unwrap();
+
+        // Images without force_sticker should be turned into [Viewtype::Image]
+        let mut msg = Message::new(Viewtype::Sticker);
+        msg.set_file(file.to_str().unwrap(), None);
+        let sent_msg = alice.send_msg(alice_chat.id, &mut msg).await;
+        let msg = bob.recv_msg(&sent_msg).await;
+        assert_eq!(msg.get_viewtype(), Viewtype::Image);
+
+        // Images with `force_sticker = true` should keep [Viewtype::Sticker]
+        let mut msg = Message::new(Viewtype::Sticker);
+        msg.set_file(file.to_str().unwrap(), None);
+        msg.force_sticker();
+        let sent_msg = alice.send_msg(alice_chat.id, &mut msg).await;
+        let msg = bob.recv_msg(&sent_msg).await;
+        assert_eq!(msg.get_viewtype(), Viewtype::Sticker);
+
+        // Images with `force_sticker = true` should keep [Viewtype::Sticker]
+        // even on drafted messages
+        let mut msg = Message::new(Viewtype::Sticker);
+        msg.set_file(file.to_str().unwrap(), None);
+        msg.force_sticker();
+        alice_chat
+            .id
+            .set_draft(&alice, Some(&mut msg))
+            .await
+            .unwrap();
+        let mut msg = alice_chat.id.get_draft(&alice).await.unwrap().unwrap();
+        let sent_msg = alice.send_msg(alice_chat.id, &mut msg).await;
+        let msg = bob.recv_msg(&sent_msg).await;
+        assert_eq!(msg.get_viewtype(), Viewtype::Sticker);
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sticker_gif() -> Result<()> {
         test_sticker(
             "sticker.gif",
-            include_bytes!("../test-data/image/image100x50.gif"),
-            100,
-            50,
+            include_bytes!("../test-data/image/logo.gif"),
+            Viewtype::Sticker,
+            135,
+            135,
         )
         .await
     }
@@ -5563,8 +5748,8 @@ mod tests {
         let bob_chat = bob.create_chat(&alice).await;
 
         // create sticker
-        let file_name = "sticker.jpg";
-        let bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
+        let file_name = "sticker.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::Sticker);
@@ -5941,22 +6126,40 @@ mod tests {
             get_chat_contacts(&alice, chat_bob.id).await?.pop().unwrap(),
         )
         .await?;
-        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());
+        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());
 
-        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!(!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());
+        {
+            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");
+        }
 
         Ok(())
     }
@@ -6101,7 +6304,7 @@ mod tests {
             chat_id1,
             Viewtype::Sticker,
             "b.png",
-            include_bytes!("../test-data/image/avatar64x64.png"),
+            include_bytes!("../test-data/image/logo.png"),
         )
         .await?;
         let second_image_msg_id = send_media(

src/chatlist.rs

@@ -1,6 +1,7 @@
 //! # 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::{
@@ -10,8 +11,14 @@ use crate::constants::{
 use crate::contact::{Contact, ContactId};
 use crate::context::Context;
 use crate::message::{Message, MessageState, MsgId};
+use crate::param::{Param, Params};
 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.
 ///
@@ -76,7 +83,8 @@ 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.
+    ///     are returned. When `is:unread` is contained in the query, the chatlist is
+    ///     filtered such that only chats with unread messages show up.
     /// `query_contact_id`: An optional contact ID for filtering the list. Only chats including this contact ID
     ///     are returned.
     pub async fn try_load(
@@ -170,8 +178,10 @@ impl Chatlist {
                 )
                 .await?
         } else if let Some(query) = query {
-            let query = query.trim().to_string();
-            ensure!(!query.is_empty(), "missing 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();
 
             // allow searching over special names that may change at any time
             // when the ui calls set_stock_translation()
@@ -196,42 +206,93 @@ 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),
+                    (MessageState::OutDraft, skip_id, str_like_cmd, only_unread, MessageState::InFresh),
                     process_row,
                     process_rows,
                 )
                 .await?
         } else {
-            //  show normal chatlist
-            let sort_id_up = if flag_for_forwarding {
-                ChatId::lookup_by_contact(context, ContactId::SELF)
+            let mut ids = if flag_for_forwarding {
+                let sort_id_up = ChatId::lookup_by_contact(context, ContactId::SELF)
                     .await?
-                    .unwrap_or_default()
+                    .unwrap_or_default();
+                let process_row = |row: &rusqlite::Row| {
+                    let chat_id: ChatId = row.get(0)?;
+                    let typ: Chattype = row.get(1)?;
+                    let param: Params = row.get::<_, String>(2)?.parse().unwrap_or_default();
+                    let msg_id: Option<MsgId> = row.get(3)?;
+                    Ok((chat_id, typ, param, msg_id))
+                };
+                let process_rows = |rows: rusqlite::MappedRows<_>| {
+                    rows.filter_map(|row: std::result::Result<(_, _, Params, _), _>| match row {
+                        Ok((chat_id, typ, param, msg_id)) => {
+                            if typ == Chattype::Mailinglist
+                                && param.get(Param::ListPost).is_none_or_empty()
+                            {
+                                None
+                            } else {
+                                Some(Ok((chat_id, msg_id)))
+                            }
+                        }
+                        Err(e) => Some(Err(e)),
+                    })
+                    .collect::<std::result::Result<Vec<_>, _>>()
+                    .map_err(Into::into)
+                };
+                // Return ProtectionBroken chats also, as that may happen to a verified chat at any
+                // time. It may be confusing if a chat that is normally in the list disappears
+                // suddenly. The UI need to deal with that case anyway.
+                context.sql.query_map(
+                    "SELECT c.id, c.type, c.param, m.id
+                     FROM chats c
+                     LEFT JOIN msgs m
+                            ON c.id=m.chat_id
+                           AND m.id=(
+                                   SELECT id
+                                     FROM msgs
+                                    WHERE chat_id=c.id
+                                      AND (hidden=0 OR state=?)
+                                      ORDER BY timestamp DESC, id DESC LIMIT 1)
+                     WHERE c.id>9 AND c.id!=?
+                       AND c.blocked=0
+                       AND NOT c.archived=?
+                       AND (c.type!=? OR c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?))
+                     GROUP BY c.id
+                     ORDER BY c.id=? DESC, c.archived=? DESC, IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
+                    (
+                        MessageState::OutDraft, skip_id, ChatVisibility::Archived,
+                        Chattype::Group, ContactId::SELF,
+                        sort_id_up, ChatVisibility::Pinned,
+                    ),
+                    process_row,
+                    process_rows,
+                ).await?
             } else {
-                ChatId::new(0)
+                //  show normal chatlist
+                context.sql.query_map(
+                    "SELECT c.id, m.id
+                     FROM chats c
+                     LEFT JOIN msgs m
+                            ON c.id=m.chat_id
+                           AND m.id=(
+                                   SELECT id
+                                     FROM msgs
+                                    WHERE chat_id=c.id
+                                      AND (hidden=0 OR state=?)
+                                      ORDER BY timestamp DESC, id DESC LIMIT 1)
+                     WHERE c.id>9 AND c.id!=?
+                       AND (c.blocked=0 OR c.blocked=2)
+                       AND NOT c.archived=?
+                     GROUP BY c.id
+                     ORDER BY c.id=0 DESC, c.archived=? DESC, IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
+                    (MessageState::OutDraft, skip_id, ChatVisibility::Archived, ChatVisibility::Pinned),
+                    process_row,
+                    process_rows,
+                ).await?
             };
-            let mut ids = context.sql.query_map(
-                "SELECT c.id, m.id
-                 FROM chats c
-                 LEFT JOIN msgs m
-                        ON c.id=m.chat_id
-                       AND m.id=(
-                               SELECT id
-                                 FROM msgs
-                                WHERE chat_id=c.id
-                                  AND (hidden=0 OR state=?1)
-                                  ORDER BY timestamp DESC, id DESC LIMIT 1)
-                 WHERE c.id>9 AND c.id!=?2
-                   AND (c.blocked=0 OR (c.blocked=2 AND NOT ?3))
-                   AND NOT c.archived=?4
-                 GROUP BY c.id
-                 ORDER BY c.id=?5 DESC, c.archived=?6 DESC, IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                (MessageState::OutDraft, skip_id, flag_for_forwarding, ChatVisibility::Archived, sort_id_up, ChatVisibility::Pinned),
-                process_row,
-                process_rows,
-            ).await?;
             if !flag_no_specials && get_archived_cnt(context).await? > 0 {
                 if ids.is_empty() && flag_add_alldone_hint {
                     ids.push((DC_CHAT_ID_ALLDONE_HINT, None));
@@ -244,6 +305,27 @@ impl Chatlist {
         Ok(Chatlist { ids })
     }
 
+    /// Converts list of chat IDs to a chatlist.
+    pub(crate) async fn from_chat_ids(context: &Context, chat_ids: &[ChatId]) -> Result<Self> {
+        let mut ids = Vec::new();
+        for &chat_id in chat_ids {
+            let msg_id: Option<MsgId> = context
+                .sql
+                .query_get_value(
+                    "SELECT id
+                   FROM msgs
+                  WHERE chat_id=?1
+                    AND (hidden=0 OR state=?2)
+                  ORDER BY timestamp DESC, id DESC LIMIT 1",
+                    (chat_id, MessageState::OutDraft),
+                )
+                .await
+                .with_context(|| format!("failed to get msg ID for chat {}", chat_id))?;
+            ids.push((chat_id, msg_id));
+        }
+        Ok(Chatlist { ids })
+    }
+
     /// Find out the number of chats.
     pub fn len(&self) -> usize {
         self.ids.len()
@@ -388,7 +470,10 @@ pub async fn get_last_message_for_chat(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::chat::{create_group_chat, get_chat_contacts, ProtectionStatus};
+    use crate::chat::{
+        add_contact_to_chat, create_group_chat, get_chat_contacts, remove_contact_from_chat,
+        send_text_msg, ProtectionStatus,
+    };
     use crate::message::Viewtype;
     use crate::receive_imf::receive_imf;
     use crate::stock_str::StockMessage;
@@ -396,7 +481,7 @@ mod tests {
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_try_load() {
-        let t = TestContext::new().await;
+        let t = TestContext::new_bob().await;
         let chat_id1 = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat")
             .await
             .unwrap();
@@ -435,6 +520,31 @@ 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();
@@ -473,6 +583,14 @@ mod tests {
             .await
             .unwrap()
             .is_self_talk());
+
+        remove_contact_from_chat(&t, chats.get_chat_id(1).unwrap(), ContactId::SELF)
+            .await
+            .unwrap();
+        let chats = Chatlist::try_load(&t, DC_GCL_FOR_FORWARDING, None, None)
+            .await
+            .unwrap();
+        assert!(chats.len() == 1);
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

src/config.rs

@@ -1,6 +1,7 @@
 //! # Key-value configuration management.
 
 use std::env;
+use std::path::Path;
 use std::str::FromStr;
 
 use anyhow::{ensure, Context as _, Result};
@@ -285,15 +286,20 @@ 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"))]
     DownloadLimit,
 
-    /// Send sync messages, requires `BccSelf` to be set as well.
-    /// In a future versions, this switch may be removed.
+    /// Enable sending and executing (applying) sync messages. Sending requires `BccSelf` to be set.
     #[strum(props(default = "0"))]
-    SendSyncMsgs,
+    SyncMsgs,
 
     /// Space-separated list of all the authserv-ids which we believe
     /// may be the one of our email server.
@@ -312,6 +318,13 @@ 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,
+
     /// Feature flag for verified 1:1 chats; the UI should set it
     /// to 1 if it supports verified 1:1 chats.
     /// Regardless of this setting, `chat.is_protected()` returns true while the key is verified,
@@ -339,7 +352,11 @@ impl Context {
         let value = match key {
             Config::Selfavatar => {
                 let rel_path = self.sql.get_raw_config(key.as_ref()).await?;
-                rel_path.map(|p| get_abs_path(self, p).to_string_lossy().into_owned())
+                rel_path.map(|p| {
+                    get_abs_path(self, Path::new(&p))
+                        .to_string_lossy()
+                        .into_owned()
+                })
             }
             Config::SysVersion => Some((*DC_VERSION_STR).clone()),
             Config::SysMsgsizeMaxRecommended => Some(format!("{RECOMMENDED_FILE_SIZE}")),
@@ -470,6 +487,28 @@ 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::SyncMsgs
+            | 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?;
             }
@@ -619,6 +658,18 @@ 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,7 +26,6 @@ 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};
@@ -130,7 +129,7 @@ async fn on_configure_completed(
     old_addr: Option<String>,
 ) -> Result<()> {
     if let Some(provider) = param.provider {
-        if let Some(config_defaults) = &provider.config_defaults {
+        if let Some(config_defaults) = provider.config_defaults {
             for def in config_defaults {
                 if !context.config_exists(def.key).await? {
                     info!(context, "apply config_defaults {}={}", def.key, def.value);
@@ -466,7 +465,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.");
-            job::schedule_resync(ctx).await?;
+            ctx.schedule_resync().await?;
         }
     }
 

src/constants.rs

@@ -62,8 +62,15 @@ pub enum MediaQuality {
 pub enum KeyGenType {
     #[default]
     Default = 0,
+
+    /// 2048-bit RSA.
     Rsa2048 = 1,
+
+    /// [Ed25519](https://ed25519.cr.yp.to/) signature and X25519 encryption.
     Ed25519 = 2,
+
+    /// 4096-bit RSA.
+    Rsa4096 = 3,
 }
 
 /// Video chat URL type.
@@ -224,6 +231,7 @@ mod tests {
         assert_eq!(KeyGenType::Default, KeyGenType::from_i32(0).unwrap());
         assert_eq!(KeyGenType::Rsa2048, KeyGenType::from_i32(1).unwrap());
         assert_eq!(KeyGenType::Ed25519, KeyGenType::from_i32(2).unwrap());
+        assert_eq!(KeyGenType::Rsa4096, KeyGenType::from_i32(3).unwrap());
     }
 
     #[test]

src/contact.rs

@@ -5,7 +5,7 @@ use std::collections::BinaryHeap;
 use std::convert::{TryFrom, TryInto};
 use std::fmt;
 use std::ops::Deref;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{bail, ensure, Context as _, Result};
@@ -109,7 +109,7 @@ impl ContactId {
 
     /// ID of the contact for device messages.
     pub const DEVICE: ContactId = ContactId::new(5);
-    const LAST_SPECIAL: ContactId = ContactId::new(9);
+    pub(crate) const LAST_SPECIAL: ContactId = ContactId::new(9);
 
     /// Address to go with [`ContactId::DEVICE`].
     ///
@@ -139,6 +139,15 @@ impl ContactId {
     pub const fn to_u32(&self) -> u32 {
         self.0
     }
+
+    /// Mark contact as bot.
+    pub(crate) async fn mark_bot(&self, context: &Context, is_bot: bool) -> Result<()> {
+        context
+            .sql
+            .execute("UPDATE contacts SET is_bot=? WHERE id=?;", (is_bot, self.0))
+            .await?;
+        Ok(())
+    }
 }
 
 impl fmt::Display for ContactId {
@@ -223,6 +232,9 @@ pub struct Contact {
 
     /// Last seen message signature for this contact, to be displayed in the profile.
     status: String,
+
+    /// If the contact is a bot.
+    is_bot: bool,
 }
 
 /// Possible origins of a contact.
@@ -366,7 +378,7 @@ impl Contact {
             .sql
             .query_row_optional(
                 "SELECT c.name, c.addr, c.origin, c.blocked, c.last_seen,
-                c.authname, c.param, c.status
+                c.authname, c.param, c.status, c.is_bot
                FROM contacts c
               WHERE c.id=?;",
                 (contact_id,),
@@ -379,6 +391,7 @@ impl Contact {
                     let authname: String = row.get(5)?;
                     let param: String = row.get(6)?;
                     let status: Option<String> = row.get(7)?;
+                    let is_bot: bool = row.get(8)?;
                     let contact = Self {
                         id: contact_id,
                         name,
@@ -389,6 +402,7 @@ impl Contact {
                         origin,
                         param: param.parse().unwrap_or_default(),
                         status: status.unwrap_or_default(),
+                        is_bot,
                     };
                     Ok(contact)
                 },
@@ -498,6 +512,11 @@ impl Contact {
         Ok(())
     }
 
+    /// Returns whether contact is a bot.
+    pub fn is_bot(&self) -> bool {
+        self.is_bot
+    }
+
     /// Check if an e-mail address belongs to a known and unblocked contact.
     ///
     /// Known and unblocked contacts will be returned by `get_contacts()`.
@@ -812,7 +831,11 @@ 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
@@ -832,7 +855,7 @@ impl Contact {
                     ),
                     rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
                         ContactId::LAST_SPECIAL,
-                        Origin::IncomingReplyTo,
+                        minimal_origin,
                         s3str_like_cmd,
                         s3str_like_cmd,
                         if flag_verified_only { 0i32 } else { 1i32 }
@@ -882,10 +905,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,
-                        Origin::IncomingReplyTo
-                    ])),
+                    rusqlite::params_from_iter(
+                        params_iter(&self_addrs)
+                            .chain(params_slice![ContactId::LAST_SPECIAL, minimal_origin]),
+                    ),
                     |row| row.get::<_, ContactId>(0),
                     |ids| {
                         for id in ids {
@@ -1186,7 +1209,7 @@ impl Contact {
             }
         } else if let Some(image_rel) = self.param.get(Param::ProfileImage) {
             if !image_rel.is_empty() {
-                return Ok(Some(get_abs_path(context, image_rel)));
+                return Ok(Some(get_abs_path(context, Path::new(image_rel))));
             }
         }
         Ok(None)
@@ -1236,11 +1259,22 @@ impl Contact {
 
     /// Returns the ContactId that verified the contact.
     pub async fn get_verifier_id(&self, context: &Context) -> Result<Option<ContactId>> {
-        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)
+        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)
+            }
         }
     }
 
@@ -1716,7 +1750,7 @@ mod tests {
         assert_eq!(may_be_valid_addr("dd.tt"), false);
         assert_eq!(may_be_valid_addr("tt.dd@uu"), true);
         assert_eq!(may_be_valid_addr("u@d"), true);
-        assert_eq!(may_be_valid_addr("u@d."), true);
+        assert_eq!(may_be_valid_addr("u@d."), false);
         assert_eq!(may_be_valid_addr("u@d.t"), true);
         assert_eq!(may_be_valid_addr("u@d.tt"), true);
         assert_eq!(may_be_valid_addr("u@.tt"), true);
@@ -1725,6 +1759,7 @@ mod tests {
         assert_eq!(may_be_valid_addr("sk <@d.tt>"), false);
         assert_eq!(may_be_valid_addr("as@sd.de>"), false);
         assert_eq!(may_be_valid_addr("ask dkl@dd.tt"), false);
+        assert_eq!(may_be_valid_addr("user@domain.tld."), false);
     }
 
     #[test]

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;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
@@ -23,7 +23,7 @@ use crate::key::{load_self_public_key, DcKey as _};
 use crate::login_param::LoginParam;
 use crate::message::{self, MessageState, MsgId};
 use crate::quota::QuotaInfo;
-use crate::scheduler::SchedulerState;
+use crate::scheduler::{InterruptInfo, 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 unecrypted database:
+/// Creating a new unencrypted database:
 ///
 /// ```
 /// # let rt = tokio::runtime::Runtime::new().unwrap();
@@ -211,9 +211,6 @@ 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,
 
@@ -332,6 +329,12 @@ impl Context {
         }
     }
 
+    /// Changes encrypted database passphrase.
+    pub async fn change_passphrase(&self, passphrase: String) -> Result<()> {
+        self.sql.change_passphrase(passphrase).await?;
+        Ok(())
+    }
+
     /// Returns true if database is open.
     pub async fn is_open(&self) -> bool {
         self.sql.is_open().await
@@ -376,9 +379,8 @@ impl Context {
             translated_stockstrings: stockstrings,
             events,
             scheduler: SchedulerState::new(),
-            ratelimit: RwLock::new(Ratelimit::new(Duration::new(60, 0), 6.0)), // Allow to send 6 messages immediately, no more than once every 10 seconds.
+            ratelimit: RwLock::new(Ratelimit::new(Duration::new(60, 0), 6.0)), // Allow at least 1 message every 10 seconds + a burst of 6.
             quota: RwLock::new(None),
-            quota_update_request: AtomicBool::new(false),
             resync_request: AtomicBool::new(false),
             new_msgs_notify,
             server_id: RwLock::new(None),
@@ -420,6 +422,16 @@ 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.
@@ -572,7 +584,8 @@ impl Context {
         let e2ee_enabled = self.get_config_int(Config::E2eeEnabled).await?;
         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 sync_msgs = self.get_config_int(Config::SyncMsgs).await?;
+        let disable_idle = self.get_config_bool(Config::DisableIdle).await?;
 
         let prv_key_cnt = self.sql.count("SELECT COUNT(*) FROM keypairs;", ()).await?;
 
@@ -684,7 +697,8 @@ impl Context {
             self.get_config_int(Config::KeyGenType).await?.to_string(),
         );
         res.insert("bcc_self", bcc_self.to_string());
-        res.insert("send_sync_msgs", send_sync_msgs.to_string());
+        res.insert("sync_msgs", 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);
@@ -746,7 +760,6 @@ impl Context {
                 .await?
                 .to_string(),
         );
-
         res.insert(
             "debug_logging",
             self.get_config_int(Config::DebugLogging).await?.to_string(),
@@ -755,6 +768,10 @@ 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(),
+        );
         res.insert(
             "verified_one_on_one_chats",
             self.get_config_bool(Config::VerifiedOneOnOneChats)
@@ -814,7 +831,22 @@ 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 => MsgId::new_unset(),
+            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?
+            }
         };
 
         let list = self
@@ -1459,6 +1491,35 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_context_change_passphrase() -> Result<()> {
+        let dir = tempdir()?;
+        let dbfile = dir.path().join("db.sqlite");
+
+        let id = 1;
+        let context = Context::new_closed(&dbfile, id, Events::new(), StockStrings::new())
+            .await
+            .context("failed to create context")?;
+        assert_eq!(context.open("foo".to_string()).await?, true);
+        assert_eq!(context.is_open().await, true);
+
+        context
+            .set_config(Config::Addr, Some("alice@example.org"))
+            .await?;
+
+        context
+            .change_passphrase("bar".to_string())
+            .await
+            .context("Failed to change passphrase")?;
+
+        assert_eq!(
+            context.get_config(Config::Addr).await?.unwrap(),
+            "alice@example.org"
+        );
+
+        Ok(())
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ongoing() -> Result<()> {
         let context = TestContext::new().await;

src/decrypt.rs

@@ -28,14 +28,30 @@ pub fn try_decrypt(
     private_keyring: &[SignedSecretKey],
     public_keyring_for_validate: &[SignedPublicKey],
 ) -> Result<Option<(Vec<u8>, HashSet<Fingerprint>)>> {
-    let encrypted_data_part = match get_autocrypt_mime(mail)
-        .or_else(|| get_mixed_up_mime(mail))
-        .or_else(|| get_attachment_mime(mail))
-    {
+    let encrypted_data_part = match {
+        let mime = get_autocrypt_mime(mail);
+        if mime.is_some() {
+            info!(context, "Detected Autocrypt-mime message.");
+        }
+        mime
+    }
+    .or_else(|| {
+        let mime = get_mixed_up_mime(mail);
+        if mime.is_some() {
+            info!(context, "Detected mixed-up mime message.");
+        }
+        mime
+    })
+    .or_else(|| {
+        let mime = get_attachment_mime(mail);
+        if mime.is_some() {
+            info!(context, "Detected attached Autocrypt-mime message.");
+        }
+        mime
+    }) {
         None => return Ok(None),
         Some(res) => res,
     };
-    info!(context, "Detected Autocrypt-mime message");
 
     decrypt_part(
         encrypted_data_part,
@@ -402,4 +418,18 @@ mod tests {
 
         Ok(())
     }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_mixed_up_mime_long() -> Result<()> {
+        // Long "mixed-up" mail as received when sending an encrypted message using Delta Chat
+        // Desktop via MS Exchange (actually made with TB though).
+        let mixed_up_mime = include_bytes!("../test-data/message/mixed-up-long.eml");
+        let bob = TestContext::new_bob().await;
+        receive_imf(&bob, mixed_up_mime, false).await?;
+        let msg = bob.get_last_msg().await;
+        assert!(!msg.get_text().is_empty());
+        assert!(msg.has_html());
+        assert!(msg.id.get_html(&bob).await?.unwrap().len() > 40000);
+        Ok(())
+    }
 }

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::{job_try, stock_str, EventType};
+use crate::{stock_str, EventType};
 
 /// Download limits should not be used below `MIN_DOWNLOAD_LIMIT`.
 ///
@@ -23,7 +23,7 @@ use crate::{job_try, stock_str, EventType};
 /// eg. to assign them to the correct chat.
 /// As these messages are typically small,
 /// they're caught by `MIN_DOWNLOAD_LIMIT`.
-const MIN_DOWNLOAD_LIMIT: u32 = 32768;
+pub(crate) 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"),
@@ -59,6 +59,9 @@ pub enum DownloadState {
     /// Failed to fully download the message.
     Failure = 20,
 
+    /// Undecipherable message.
+    Undecipherable = 30,
+
     /// Full download of the message is in progress.
     InProgress = 1000,
 }
@@ -80,12 +83,21 @@ impl MsgId {
     pub async fn download_full(self, context: &Context) -> Result<()> {
         let msg = Message::load_from_db(context, self).await?;
         match msg.download_state() {
-            DownloadState::Done => return Err(anyhow!("Nothing to download.")),
+            DownloadState::Done | DownloadState::Undecipherable => {
+                return Err(anyhow!("Nothing to download."))
+            }
             DownloadState::InProgress => return Err(anyhow!("Download already in progress.")),
             DownloadState::Available | DownloadState::Failure => {
                 self.update_download_state(context, DownloadState::InProgress)
                     .await?;
-                job::add(context, Job::new(Action::DownloadMsg, self.to_u32())).await?;
+                context
+                    .sql
+                    .execute("INSERT INTO download (msg_id) VALUES (?)", (self,))
+                    .await?;
+                context
+                    .scheduler
+                    .interrupt_inbox(InterruptInfo::new(false))
+                    .await;
             }
         }
         Ok(())
@@ -119,59 +131,49 @@ impl Message {
     }
 }
 
-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;
-        }
+/// 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?;
 
-        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
-        );
+    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?;
 
-        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!(
+    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 => {
                 msg.id
                     .update_download_state(context, DownloadState::Failure)
-                    .await
-            );
-            Status::Finished(Err(anyhow!("Call download_full() again to try over.")))
+                    .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(())
+            }
         }
+    } 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/ephemeral.rs

@@ -1062,14 +1062,14 @@ mod tests {
         delete_expired_messages(t, not_deleted_at).await?;
 
         let loaded = Message::load_from_db(t, msg_id).await?;
-        assert_eq!(loaded.text, "Message text");
+        assert!(!loaded.text.is_empty());
         assert_eq!(loaded.chat_id, chat.id);
 
         assert!(next_expiration < deleted_at);
         delete_expired_messages(t, deleted_at).await?;
         t.evtracker
             .get_matching(|evt| {
-                if let EventType::MsgsChanged {
+                if let EventType::MsgDeleted {
                     msg_id: event_msg_id,
                     ..
                 } = evt
@@ -1082,7 +1082,6 @@ mod tests {
             .await;
 
         let loaded = Message::load_from_db(t, msg_id).await?;
-        assert_eq!(loaded.text, "");
         assert_eq!(loaded.chat_id, DC_CHAT_ID_TRASH);
 
         // Check that the msg was deleted locally.
@@ -1300,4 +1299,32 @@ mod tests {
 
         Ok(())
     }
+
+    // Tests that if we are offline for a time longer than the ephemeral timer duration, the message
+    // is deleted from the chat but is still in the "smtp" table, i.e. will be sent upon a
+    // successful reconnection.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_ephemeral_msg_offline() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let chat = alice
+            .create_chat_with_contact("Bob", "bob@example.org")
+            .await;
+        let duration = 60;
+        chat.id
+            .set_ephemeral_timer(&alice, Timer::Enabled { duration })
+            .await?;
+        let mut msg = Message::new(Viewtype::Text);
+        msg.set_text("hi".to_string());
+        assert!(chat::send_msg_sync(&alice, chat.id, &mut msg)
+            .await
+            .is_err());
+        let stmt = "SELECT COUNT(*) FROM smtp WHERE msg_id=?";
+        assert!(alice.sql.exists(stmt, (msg.id,)).await?);
+        let now = time();
+        check_msg_will_be_deleted(&alice, msg.id, &chat, now, now + i64::from(duration) + 1)
+            .await?;
+        assert!(alice.sql.exists(stmt, (msg.id,)).await?);
+
+        Ok(())
+    }
 }

src/imap.rs

@@ -26,7 +26,6 @@ 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;
@@ -82,7 +81,6 @@ 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])";
 
@@ -391,6 +389,7 @@ impl Imap {
                     "IMAP-LOGIN as {}",
                     self.config.lp.user
                 )));
+                self.connectivity.set_connected(context).await;
                 info!(context, "Successfully logged into IMAP server");
                 Ok(())
             }
@@ -614,7 +613,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?;
-                    job::schedule_resync(context).await?;
+                    context.schedule_resync().await?;
                 }
                 uid_next != old_uid_next // If uid_next changed, there are new emails
             } else {
@@ -626,18 +625,6 @@ 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 {
@@ -645,25 +632,35 @@ impl Imap {
             None => {
                 warn!(
                     context,
-                    "IMAP folder {folder:?} has no uid_next, fall back to fetching."
+                    "SELECT response for IMAP folder {folder:?} has no UIDNEXT, fall back to STATUS command."
                 );
-                // 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
-                    .fetch(set, JUST_UID)
-                    .await
-                    .context("Error fetching UID")?;
 
-                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;
-                    }
+                // 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
+                    .inner
+                    .status(folder, "(UIDNEXT)")
+                    .await
+                    .context("STATUS (UIDNEXT) error for {folder:?}")?;
+
+                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
                 }
-                new_last_seen_uid.context("select: failed to fetch")? + 1
             }
         };
 
@@ -680,7 +677,7 @@ impl Imap {
             .await?;
 
         if old_uid_validity != 0 || old_uid_next != 0 {
-            job::schedule_resync(context).await?;
+            context.schedule_resync().await?;
         }
         info!(
             context,

src/imap/client.rs

@@ -15,6 +15,7 @@ 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);
@@ -64,6 +65,12 @@ 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
@@ -98,27 +105,24 @@ 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 = ImapClient::new(session_stream);
-
+        let mut client = Client::new(session_stream);
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(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 = ImapClient::new(session_stream);
+        let mut client = Client::new(session_stream);
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(client)
     }
 
     pub async fn connect_starttls(
@@ -130,7 +134,8 @@ 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 mut client = ImapClient::new(tcp_stream);
+        let buffered_tcp_stream = BufWriter::new(tcp_stream);
+        let mut client = ImapClient::new(buffered_tcp_stream);
         let _greeting = client
             .read_response()
             .await
@@ -139,7 +144,8 @@ impl Client {
             .run_command_and_check_ok("STARTTLS", None)
             .await
             .context("STARTTLS command failed")?;
-        let tcp_stream = client.into_inner();
+        let buffered_tcp_stream = client.into_inner();
+        let tcp_stream = buffered_tcp_stream.into_inner();
 
         let tls_stream = wrap_tls(strict_tls, hostname, tcp_stream)
             .await
@@ -147,9 +153,8 @@ impl Client {
 
         let buffered_stream = BufWriter::new(tls_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let client = ImapClient::new(session_stream);
-
-        Ok(Client { inner: client })
+        let client = Client::new(session_stream);
+        Ok(client)
     }
 
     pub async fn connect_secure_socks5(
@@ -165,13 +170,12 @@ 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 = ImapClient::new(session_stream);
+        let mut client = Client::new(session_stream);
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(client)
     }
 
     pub async fn connect_insecure_socks5(
@@ -185,13 +189,12 @@ impl Client {
             .await?;
         let buffered_stream = BufWriter::new(socks5_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
-        let mut client = ImapClient::new(session_stream);
+        let mut client = Client::new(session_stream);
         let _greeting = client
             .read_response()
             .await
             .context("failed to read greeting")??;
-
-        Ok(Client { inner: client })
+        Ok(client)
     }
 
     pub async fn connect_starttls_socks5(
@@ -206,7 +209,8 @@ impl Client {
             .await?;
 
         // Run STARTTLS command and convert the client back into a stream.
-        let mut client = ImapClient::new(socks5_stream);
+        let buffered_socks5_stream = BufWriter::new(socks5_stream);
+        let mut client = ImapClient::new(buffered_socks5_stream);
         let _greeting = client
             .read_response()
             .await
@@ -215,15 +219,15 @@ impl Client {
             .run_command_and_check_ok("STARTTLS", None)
             .await
             .context("STARTTLS command failed")?;
-        let socks5_stream = client.into_inner();
+        let buffered_socks5_stream = client.into_inner();
+        let socks5_stream: Socks5Stream<_> = buffered_socks5_stream.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 = ImapClient::new(session_stream);
-
-        Ok(Client { inner: client })
+        let client = Client::new(session_stream);
+        Ok(client)
     }
 }

src/imap/idle.rs

@@ -7,7 +7,9 @@ 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);
@@ -21,6 +23,10 @@ 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");
         }
@@ -163,7 +169,14 @@ impl Imap {
                         continue;
                     }
                     if let Some(session) = &self.session {
-                        if session.can_idle() {
+                        if session.can_idle()
+                            && !context
+                                .get_config_bool(Config::DisableIdle)
+                                .await
+                                .context("Failed to get disable_idle config")
+                                .log_err(context)
+                                .unwrap_or_default()
+                        {
                             // we only fake-idled because network was gone during IDLE, probably
                             break InterruptInfo::new(false);
                         }

src/imex.rs

@@ -60,8 +60,7 @@ 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 typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
-    /// the format is `delta-chat-<day>-<number>.tar`
+    /// The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.tar`.
     ExportBackup = 11,
 
     /// `path` is the file (not: directory) to import. The file is normally
@@ -130,7 +129,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-2020-07-24-00.tar
+            // This works fine because the filenames have the form `delta-chat-backup-2023-10-18-00-foo@example.com.tar`
             newest_backup_path = Some(path);
             newest_backup_name = name;
         }
@@ -486,7 +485,11 @@ 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, backup_time: i64) -> Result<(PathBuf, PathBuf, PathBuf)> {
+fn get_next_backup_path(
+    folder: &Path,
+    addr: &str,
+    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")?
@@ -497,13 +500,13 @@ fn get_next_backup_path(folder: &Path, backup_time: i64) -> Result<(PathBuf, Pat
     // 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}.db"));
+        tempdbfile.push(format!("{stem}-{i:02}-{addr}.db"));
 
         let mut tempfile = folder.clone();
-        tempfile.push(format!("{stem}-{i:02}.tar.part"));
+        tempfile.push(format!("{stem}-{i:02}-{addr}.tar.part"));
 
         let mut destfile = folder.clone();
-        destfile.push(format!("{stem}-{i:02}.tar"));
+        destfile.push(format!("{stem}-{i:02}-{addr}.tar"));
 
         if !tempdbfile.exists() && !tempfile.exists() && !destfile.exists() {
             return Ok((tempdbfile, tempfile, destfile));
@@ -518,7 +521,8 @@ fn get_next_backup_path(folder: &Path, backup_time: i64) -> Result<(PathBuf, Pat
 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 (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, now)?;
+    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 _d1 = DeleteOnDrop(temp_db_path.clone());
     let _d2 = DeleteOnDrop(temp_path.clone());
 
@@ -588,63 +592,74 @@ async fn export_backup_inner(
     Ok(())
 }
 
-/*******************************************************************************
- * Classic key import
- ******************************************************************************/
-async fn import_self_keys(context: &Context, dir: &Path) -> Result<()> {
-    /* hint: even if we switch to import Autocrypt Setup Files, we should leave the possibility to import
-    plain ASC keys, at least keys without a password, if we do not want to implement a password entry function.
-    Importing ASC keys is useful to use keys in Delta Chat used by any other non-Autocrypt-PGP implementation.
+/// Imports secret key from a file.
+async fn import_secret_key(context: &Context, path: &Path, set_default: bool) -> Result<()> {
+    let buf = read_file(context, &path).await?;
+    let armored = std::string::String::from_utf8_lossy(&buf);
+    set_self_key(context, &armored, set_default, false).await?;
+    Ok(())
+}
+
+/// Imports secret keys from the provided file or directory.
+///
+/// If provided path is a file, ASCII-armored secret key is read from the file
+/// and set as the default key.
+///
+/// If provided path is a directory, all files with .asc extension
+/// containing secret keys are imported and the last successfully
+/// imported which does not contain "legacy" in its filename
+/// is set as the default.
+async fn import_self_keys(context: &Context, path: &Path) -> Result<()> {
+    let attr = tokio::fs::metadata(path).await?;
+
+    if attr.is_file() {
+        info!(
+            context,
+            "Importing secret key from {} as the default key.",
+            path.display()
+        );
+        let set_default = true;
+        import_secret_key(context, path, set_default).await?;
+        return Ok(());
+    }
 
-    Maybe we should make the "default" key handlong also a little bit smarter
-    (currently, the last imported key is the standard key unless it contains the string "legacy" in its name) */
-    let mut set_default: bool;
     let mut imported_cnt = 0;
 
-    let dir_name = dir.to_string_lossy();
-    let mut dir_handle = tokio::fs::read_dir(&dir).await?;
+    let mut dir_handle = tokio::fs::read_dir(&path).await?;
     while let Ok(Some(entry)) = dir_handle.next_entry().await {
         let entry_fn = entry.file_name();
         let name_f = entry_fn.to_string_lossy();
-        let path_plus_name = dir.join(&entry_fn);
-        match get_filesuffix_lc(&name_f) {
-            Some(suffix) => {
-                if suffix != "asc" {
-                    continue;
-                }
-                set_default = if name_f.contains("legacy") {
-                    info!(context, "found legacy key '{}'", path_plus_name.display());
-                    false
-                } else {
-                    true
-                }
-            }
-            None => {
+        let path_plus_name = path.join(&entry_fn);
+        if let Some(suffix) = get_filesuffix_lc(&name_f) {
+            if suffix != "asc" {
                 continue;
             }
-        }
+        } else {
+            continue;
+        };
+        let set_default = !name_f.contains("legacy");
         info!(
             context,
-            "considering key file: {}",
+            "Considering key file: {}.",
             path_plus_name.display()
         );
 
-        match read_file(context, &path_plus_name).await {
-            Ok(buf) => {
-                let armored = std::string::String::from_utf8_lossy(&buf);
-                if let Err(err) = set_self_key(context, &armored, set_default, false).await {
-                    info!(context, "set_self_key: {}", err);
-                    continue;
-                }
-            }
-            Err(_) => continue,
+        if let Err(err) = import_secret_key(context, &path_plus_name, set_default).await {
+            warn!(
+                context,
+                "Failed to import secret key from {}: {:#}.",
+                path_plus_name.display(),
+                err
+            );
+            continue;
         }
+
         imported_cnt += 1;
     }
     ensure!(
         imported_cnt > 0,
-        "No private keys found in \"{}\".",
-        dir_name
+        "No private keys found in {}.",
+        path.display()
     );
     Ok(())
 }
@@ -675,7 +690,8 @@ async fn export_self_keys(context: &Context, dir: &Path) -> Result<()> {
         .await?;
 
     for (id, public_key, private_key, is_default) in keys {
-        let id = Some(id).filter(|_| is_default != 0);
+        let id = Some(id).filter(|_| is_default == 0);
+
         if let Ok(key) = public_key {
             if let Err(err) = export_key_to_asc_file(context, dir, id, &key).await {
                 error!(context, "Failed to export public key: {:#}.", err);
@@ -771,6 +787,11 @@ async fn export_database(context: &Context, dest: &Path, passphrase: String) ->
             let res = conn
                 .query_row("SELECT sqlcipher_export('backup')", [], |_row| Ok(()))
                 .context("failed to export to attached backup database");
+            conn.execute(
+                "UPDATE backup.config SET value='0' WHERE keyname='verified_one_on_one_chats';",
+                [],
+            )
+            .ok(); // If verified_one_on_one_chats was not set, this errors, which we ignore
             conn.execute("DETACH DATABASE backup", [])
                 .context("failed to detach backup database")?;
             res?;
@@ -866,69 +887,108 @@ mod tests {
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_export_and_import_key() {
+        let export_dir = tempfile::tempdir().unwrap();
+
         let context = TestContext::new_alice().await;
-        let blobdir = context.ctx.get_blobdir();
-        if let Err(err) = imex(&context.ctx, ImexMode::ExportSelfKeys, blobdir, None).await {
+        if let Err(err) = imex(
+            &context.ctx,
+            ImexMode::ExportSelfKeys,
+            export_dir.path(),
+            None,
+        )
+        .await
+        {
             panic!("got error on export: {err:#}");
         }
 
         let context2 = TestContext::new_alice().await;
-        if let Err(err) = imex(&context2.ctx, ImexMode::ImportSelfKeys, blobdir, None).await {
+        if let Err(err) = imex(
+            &context2.ctx,
+            ImexMode::ImportSelfKeys,
+            export_dir.path(),
+            None,
+        )
+        .await
+        {
+            panic!("got error on import: {err:#}");
+        }
+
+        let keyfile = export_dir.path().join("private-key-default.asc");
+        let context3 = TestContext::new_alice().await;
+        if let Err(err) = imex(&context3.ctx, ImexMode::ImportSelfKeys, &keyfile, None).await {
             panic!("got error on import: {err:#}");
         }
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_export_and_import_backup() -> Result<()> {
-        let backup_dir = tempfile::tempdir().unwrap();
+        for set_verified_oneonone_chats in [true, false] {
+            let backup_dir = tempfile::tempdir().unwrap();
 
-        let context1 = TestContext::new_alice().await;
-        assert!(context1.is_configured().await?);
+            let context1 = TestContext::new_alice().await;
+            assert!(context1.is_configured().await?);
+            if set_verified_oneonone_chats {
+                context1
+                    .set_config_bool(Config::VerifiedOneOnOneChats, true)
+                    .await?;
+            }
 
-        let context2 = TestContext::new().await;
-        assert!(!context2.is_configured().await?);
-        assert!(has_backup(&context2, backup_dir.path()).await.is_err());
+            let context2 = TestContext::new().await;
+            assert!(!context2.is_configured().await?);
+            assert!(has_backup(&context2, backup_dir.path()).await.is_err());
 
-        // export from context1
-        assert!(
-            imex(&context1, ImexMode::ExportBackup, backup_dir.path(), None)
-                .await
-                .is_ok()
-        );
-        let _event = context1
-            .evtracker
-            .get_matching(|evt| matches!(evt, EventType::ImexProgress(1000)))
-            .await;
+            // export from context1
+            assert!(
+                imex(&context1, ImexMode::ExportBackup, backup_dir.path(), None)
+                    .await
+                    .is_ok()
+            );
+            let _event = context1
+                .evtracker
+                .get_matching(|evt| matches!(evt, EventType::ImexProgress(1000)))
+                .await;
 
-        // import to context2
-        let backup = has_backup(&context2, backup_dir.path()).await?;
+            // import to context2
+            let backup = has_backup(&context2, backup_dir.path()).await?;
 
-        // Import of unencrypted backup with incorrect "foobar" backup passphrase fails.
-        assert!(imex(
-            &context2,
-            ImexMode::ImportBackup,
-            backup.as_ref(),
-            Some("foobar".to_string())
-        )
-        .await
-        .is_err());
+            // Import of unencrypted backup with incorrect "foobar" backup passphrase fails.
+            assert!(imex(
+                &context2,
+                ImexMode::ImportBackup,
+                backup.as_ref(),
+                Some("foobar".to_string())
+            )
+            .await
+            .is_err());
 
-        assert!(
-            imex(&context2, ImexMode::ImportBackup, backup.as_ref(), None)
-                .await
-                .is_ok()
-        );
-        let _event = context2
-            .evtracker
-            .get_matching(|evt| matches!(evt, EventType::ImexProgress(1000)))
-            .await;
-
-        assert!(context2.is_configured().await?);
-        assert_eq!(
-            context2.get_config(Config::Addr).await?,
-            Some("alice@example.org".to_string())
-        );
+            assert!(
+                imex(&context2, ImexMode::ImportBackup, backup.as_ref(), None)
+                    .await
+                    .is_ok()
+            );
+            let _event = context2
+                .evtracker
+                .get_matching(|evt| matches!(evt, EventType::ImexProgress(1000)))
+                .await;
 
+            assert!(context2.is_configured().await?);
+            assert_eq!(
+                context2.get_config(Config::Addr).await?,
+                Some("alice@example.org".to_string())
+            );
+            assert_eq!(
+                context2
+                    .get_config_bool(Config::VerifiedOneOnOneChats)
+                    .await?,
+                false
+            );
+            assert_eq!(
+                context1
+                    .get_config_bool(Config::VerifiedOneOnOneChats)
+                    .await?,
+                set_verified_oneonone_chats
+            );
+        }
         Ok(())
     }
 

src/job.rs

@@ -1,390 +0,0 @@
-//! # 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, &mut job, &mut connection, 0).await {
-        Status::RetryNow => perform_job_action(context, &mut 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: &mut 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/key.rs

@@ -239,7 +239,7 @@ pub(crate) async fn load_keypair(
     })
 }
 
-/// Use of a [KeyPair] for encryption or decryption.
+/// Use of a key pair for encryption or decryption.
 ///
 /// This is used by [store_self_keypair] to know what kind of key is
 /// being saved.
@@ -312,15 +312,10 @@ pub async fn store_self_keypair(
 /// This API is used for testing purposes
 /// to avoid generating the key in tests.
 /// Use import/export APIs instead.
-pub async fn preconfigure_keypair(
-    context: &Context,
-    addr: &str,
-    public_data: &str,
-    secret_data: &str,
-) -> Result<()> {
+pub async fn preconfigure_keypair(context: &Context, addr: &str, secret_data: &str) -> Result<()> {
     let addr = EmailAddress::new(addr)?;
-    let public = SignedPublicKey::from_asc(public_data)?.0;
     let secret = SignedSecretKey::from_asc(secret_data)?.0;
+    let public = secret.split_public_key()?;
     let keypair = KeyPair {
         addr,
         public,

src/lib.rs

@@ -65,10 +65,6 @@ mod e2ee;
 pub mod ephemeral;
 mod imap;
 pub mod imex;
-pub mod release;
-mod scheduler;
-#[macro_use]
-mod job;
 pub mod key;
 pub mod location;
 mod login_param;
@@ -78,11 +74,13 @@ pub mod mimeparser;
 pub mod oauth2;
 mod param;
 pub mod peerstate;
-pub mod pgp;
+mod pgp;
 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) -> bool {
+pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64) -> Result<bool> {
     if latitude == 0.0 && longitude == 0.0 {
-        return true;
+        return Ok(true);
     }
     let mut continue_streaming = false;
 
-    if let Ok(chats) = context
+    let chats = context
         .sql
         .query_map(
             "SELECT id FROM chats WHERE locations_send_until>?;",
@@ -346,33 +346,29 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
                     .map_err(Into::into)
             },
         )
-        .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)));
-        };
-    }
+        .await?;
 
-    continue_streaming
+    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;
+    }
+    if continue_streaming {
+        context.emit_event(EventType::LocationChanged(Some(ContactId::SELF)));
+    };
+
+    Ok(continue_streaming)
 }
 
 /// Searches for locations in the given time range, optionally filtering by chat and contact IDs.
@@ -464,7 +460,7 @@ pub async fn delete_all(context: &Context) -> Result<()> {
 }
 
 /// Returns `location.kml` contents.
-pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)> {
+pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<Option<(String, u32)>> {
     let mut last_added_location_id = 0;
 
     let self_addr = context.get_primary_self_addr().await?;
@@ -534,9 +530,11 @@ pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)
         ret += "</Document>\n</kml>";
     }
 
-    ensure!(location_count > 0, "No locations processed");
-
-    Ok((ret, last_added_location_id))
+    if location_count > 0 {
+        Ok(Some((ret, last_added_location_id)))
+    } else {
+        Ok(None)
+    }
 }
 
 fn get_kml_timestamp(utc: i64) -> String {
@@ -928,4 +926,38 @@ 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/message.rs

@@ -7,6 +7,7 @@ use anyhow::{ensure, format_err, Context as _, Result};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
 
+use crate::blob::BlobObject;
 use crate::chat::{Chat, ChatId};
 use crate::config::Config;
 use crate::constants::{
@@ -574,14 +575,22 @@ impl Message {
                 if (self.viewtype == Viewtype::Image || self.viewtype == Viewtype::Gif)
                     && !self.param.exists(Param::Width)
                 {
-                    self.param.set_int(Param::Width, 0);
-                    self.param.set_int(Param::Height, 0);
+                    let buf = read_file(context, &path_and_filename).await?;
 
-                    if let Ok(buf) = read_file(context, path_and_filename).await {
-                        if let Ok((width, height)) = get_filemeta(&buf) {
+                    match get_filemeta(&buf) {
+                        Ok((width, height)) => {
                             self.param.set_int(Param::Width, width as i32);
                             self.param.set_int(Param::Height, height as i32);
                         }
+                        Err(err) => {
+                            self.param.set_int(Param::Width, 0);
+                            self.param.set_int(Param::Height, 0);
+                            warn!(
+                                context,
+                                "Failed to get width and height for {}: {err:#}.",
+                                path_and_filename.display()
+                            );
+                        }
                     }
 
                     if !self.id.is_unset() {
@@ -655,6 +664,12 @@ impl Message {
         self.viewtype
     }
 
+    /// Forces the message to **keep** [Viewtype::Sticker]
+    /// e.g the message will not be converted to a [Viewtype::Image].
+    pub fn force_sticker(&mut self) {
+        self.param.set_int(Param::ForceSticker, 1);
+    }
+
     /// Returns the state of the message.
     pub fn get_state(&self) -> MessageState {
         self.state
@@ -972,19 +987,28 @@ impl Message {
             }
         }
         self.param.set(Param::File, file);
-        if let Some(filemime) = filemime {
-            self.param.set(Param::MimeType, filemime);
-        }
+        self.param.set_optional(Param::MimeType, filemime);
+    }
+
+    /// Creates a new blob and sets it as a file associated with a message.
+    pub async fn set_file_from_bytes(
+        &mut self,
+        context: &Context,
+        suggested_name: &str,
+        data: &[u8],
+        filemime: Option<&str>,
+    ) -> Result<()> {
+        let blob = BlobObject::create(context, suggested_name, data).await?;
+        self.param.set(Param::File, blob.as_name());
+        self.param.set_optional(Param::MimeType, filemime);
+        Ok(())
     }
 
     /// Set different sender name for a message.
     /// This overrides the name set by the `set_config()`-option `displayname`.
     pub fn set_override_sender_name(&mut self, name: Option<String>) {
-        if let Some(name) = name {
-            self.param.set(Param::OverrideSenderDisplayname, name);
-        } else {
-            self.param.remove(Param::OverrideSenderDisplayname);
-        }
+        self.param
+            .set_optional(Param::OverrideSenderDisplayname, name);
     }
 
     /// Sets the dimensions of associated image or video file.
@@ -1421,6 +1445,7 @@ pub async fn get_mime_headers(context: &Context, msg_id: MsgId) -> Result<Vec<u8
 /// and scheduling for deletion on IMAP.
 pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
     let mut modified_chat_ids = BTreeSet::new();
+    let mut res = Ok(());
 
     for &msg_id in msg_ids {
         let msg = Message::load_from_db(context, msg_id).await?;
@@ -1444,13 +1469,19 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
         modified_chat_ids.insert(msg.chat_id);
 
         let target = context.get_delete_msgs_target().await?;
-        context
-            .sql
-            .execute(
+        let update_db = |conn: &mut rusqlite::Connection| {
+            conn.execute(
                 "UPDATE imap SET target=? WHERE rfc724_mid=?",
                 (target, msg.rfc724_mid),
-            )
-            .await?;
+            )?;
+            conn.execute("DELETE FROM smtp WHERE msg_id=?", (msg_id,))?;
+            Ok(())
+        };
+        if let Err(e) = context.sql.call_write(update_db).await {
+            error!(context, "delete_msgs: failed to update db: {e:#}.");
+            res = Err(e);
+            continue;
+        }
 
         let logging_xdc_id = context
             .debug_logging
@@ -1465,6 +1496,7 @@ pub async fn delete_msgs(context: &Context, msg_ids: &[MsgId]) -> Result<()> {
             }
         }
     }
+    res?;
 
     for modified_chat_id in modified_chat_ids {
         context.emit_msgs_changed(modified_chat_id, MsgId::new(0));
@@ -1633,53 +1665,36 @@ pub(crate) async fn update_msg_state(
 
 // Context functions to work with messages
 
-/// Returns true if given message ID exists in the database and is not trashed.
-pub(crate) async fn exists(context: &Context, msg_id: MsgId) -> Result<bool> {
-    if msg_id.is_special() {
-        return Ok(false);
+pub(crate) async fn set_msg_failed(
+    context: &Context,
+    msg: &mut Message,
+    error: &str,
+) -> Result<()> {
+    if msg.state.can_fail() {
+        msg.state = MessageState::OutFailed;
+        warn!(context, "{} failed: {}", msg.id, error);
+    } else {
+        warn!(
+            context,
+            "{} seems to have failed ({}), but state is {}", msg.id, error, msg.state
+        )
     }
+    msg.error = Some(error.to_string());
 
-    let chat_id: Option<ChatId> = context
+    context
         .sql
-        .query_get_value("SELECT chat_id FROM msgs WHERE id=?;", (msg_id,))
+        .execute(
+            "UPDATE msgs SET state=?, error=? WHERE id=?;",
+            (msg.state, error, msg.id),
+        )
         .await?;
 
-    if let Some(chat_id) = chat_id {
-        Ok(!chat_id.is_trash())
-    } else {
-        Ok(false)
-    }
-}
+    context.emit_event(EventType::MsgFailed {
+        chat_id: msg.chat_id,
+        msg_id: msg.id,
+    });
 
-pub(crate) async fn set_msg_failed(context: &Context, msg_id: MsgId, error: &str) {
-    if let Ok(mut msg) = Message::load_from_db(context, msg_id).await {
-        if msg.state.can_fail() {
-            msg.state = MessageState::OutFailed;
-            warn!(context, "{} failed: {}", msg_id, error);
-        } else {
-            warn!(
-                context,
-                "{} seems to have failed ({}), but state is {}", msg_id, error, msg.state
-            )
-        }
-
-        match context
-            .sql
-            .execute(
-                "UPDATE msgs SET state=?, error=? WHERE id=?;",
-                (msg.state, error, msg_id),
-            )
-            .await
-        {
-            Ok(_) => context.emit_event(EventType::MsgFailed {
-                chat_id: msg.chat_id,
-                msg_id,
-            }),
-            Err(e) => {
-                warn!(context, "{:?}", e);
-            }
-        }
-    }
+    Ok(())
 }
 
 /// The number of messages assigned to unblocked chats
@@ -2286,7 +2301,7 @@ mod tests {
         update_msg_state(&alice, alice_msg.id, MessageState::OutMdnRcvd).await?;
         assert_state(&alice, alice_msg.id, MessageState::OutMdnRcvd).await;
 
-        set_msg_failed(&alice, alice_msg.id, "badly failed").await;
+        set_msg_failed(&alice, &mut alice_msg, "badly failed").await?;
         assert_state(&alice, alice_msg.id, MessageState::OutFailed).await;
 
         // check incoming message states on receiver side
@@ -2324,6 +2339,8 @@ mod tests {
         let msg = alice.get_last_msg().await;
         assert_eq!(msg.get_text(), "hello".to_string());
         assert!(msg.is_bot());
+        let contact = Contact::get_by_id(&alice, msg.from_id).await?;
+        assert!(contact.is_bot());
 
         // Alice receives a message from Bob who is not the bot anymore.
         receive_imf(
@@ -2341,6 +2358,8 @@ mod tests {
         let msg = alice.get_last_msg().await;
         assert_eq!(msg.get_text(), "hello again".to_string());
         assert!(!msg.is_bot());
+        let contact = Contact::get_by_id(&alice, msg.from_id).await?;
+        assert!(!contact.is_bot());
 
         Ok(())
     }
@@ -2422,4 +2441,23 @@ def hello():
 
         Ok(())
     }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_delete_msgs_offline() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let chat = alice
+            .create_chat_with_contact("Bob", "bob@example.org")
+            .await;
+        let mut msg = Message::new(Viewtype::Text);
+        msg.set_text("hi".to_string());
+        assert!(chat::send_msg_sync(&alice, chat.id, &mut msg)
+            .await
+            .is_err());
+        let stmt = "SELECT COUNT(*) FROM smtp WHERE msg_id=?";
+        assert!(alice.sql.exists(stmt, (msg.id,)).await?);
+        delete_msgs(&alice, &[msg.id]).await?;
+        assert!(!alice.sql.exists(stmt, (msg.id,)).await?);
+
+        Ok(())
+    }
 }

src/mimefactory.rs

@@ -359,9 +359,10 @@ 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 re-gossip every 48 hours
+                // beside key- and member-changes, force a periodic re-gossip.
                 let gossiped_timestamp = chat.id.get_gossiped_timestamp(context).await?;
-                if time() > gossiped_timestamp + (2 * 24 * 60 * 60) {
+                let gossip_period = context.get_config_i64(Config::GossipPeriod).await?;
+                if time() >= gossiped_timestamp + gossip_period {
                     Ok(true)
                 } else {
                     let cmd = self.msg.param.get_cmd();
@@ -414,7 +415,9 @@ impl<'a> MimeFactory<'a> {
                     return Ok(self.msg.subject.clone());
                 }
 
-                if chat.typ == Chattype::Group && quoted_msg_subject.is_none_or_empty() {
+                if (chat.typ == Chattype::Group || chat.typ == Chattype::Broadcast)
+                    && quoted_msg_subject.is_none_or_empty()
+                {
                     let re = if self.in_reply_to.is_empty() {
                         ""
                     } else {
@@ -423,15 +426,13 @@ impl<'a> MimeFactory<'a> {
                     return Ok(format!("{}{}", re, chat.name));
                 }
 
-                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 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? {
@@ -593,6 +594,15 @@ 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
@@ -678,6 +688,12 @@ 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);
 
@@ -714,10 +730,7 @@ impl<'a> MimeFactory<'a> {
             if !existing_ct.ends_with(';') {
                 existing_ct += ";";
             }
-            let message = message.replace_header(Header::new(
-                "Content-Type".to_string(),
-                format!("{existing_ct} protected-headers=\"v1\";"),
-            ));
+            let message = message.header(get_content_type_directives_header());
 
             // Set the appropriate Content-Type for the outer message
             let outer_message = PartBuilder::new().header((
@@ -786,11 +799,12 @@ 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".to_string(),
-                        "multipart/signed; protocol=\"application/pgp-signature\"".to_string(),
+                        "Content-Type",
+                        "multipart/signed; protocol=\"application/pgp-signature\"",
                     ))
                     .child(payload)
                     .child(
@@ -860,9 +874,13 @@ impl<'a> MimeFactory<'a> {
     }
 
     /// Returns MIME part with a `location.kml` attachment.
-    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?;
+    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);
+        };
+
         let part = PartBuilder::new()
             .content_type(
                 &"application/vnd.google-earth.kml+xml"
@@ -878,7 +896,7 @@ impl<'a> MimeFactory<'a> {
             // otherwise, the independent location is already filed
             self.last_added_location_id = Some(last_added_location_id);
         }
-        Ok(part)
+        Ok(Some(part))
     }
 
     #[allow(clippy::cognitive_complexity)]
@@ -1177,7 +1195,10 @@ impl<'a> MimeFactory<'a> {
         }
         let flowed_text = format_flowed(final_text);
 
-        let footer = &self.selfstatus;
+        let is_reaction = self.msg.param.get_int(Param::Reaction).unwrap_or_default() != 0;
+
+        let footer = if is_reaction { "" } else { &self.selfstatus };
+
         let message_text = format!(
             "{}{}{}{}{}{}",
             fwdhint.unwrap_or_default(),
@@ -1200,7 +1221,7 @@ impl<'a> MimeFactory<'a> {
             ))
             .body(message_text);
 
-        if self.msg.param.get_int(Param::Reaction).unwrap_or_default() != 0 {
+        if is_reaction {
             main_part = main_part.header(("Content-Disposition", "reaction"));
         }
 
@@ -1239,11 +1260,8 @@ impl<'a> MimeFactory<'a> {
         }
 
         if location::is_sending_locations_to_chat(context, Some(self.msg.chat_id)).await? {
-            match self.get_location_kml_part(context).await {
-                Ok(part) => parts.push(part),
-                Err(err) => {
-                    warn!(context, "mimefactory: could not send location: {}", err);
-                }
+            if let Some(part) = self.get_location_kml_part(context).await? {
+                parts.push(part);
             }
         }
 
@@ -1372,15 +1390,16 @@ impl<'a> MimeFactory<'a> {
     }
 }
 
-/// Returns base64-encoded buffer `buf` split into 78-bytes long
+/// Returns base64-encoded buffer `buf` split into 76-bytes long
 /// chunks separated by CRLF.
 ///
-/// This line length limit is an
-/// [RFC5322 requirement](https://tools.ietf.org/html/rfc5322#section-2.1.1).
+/// [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.
 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(78).collect::<String>())
+    std::iter::repeat_with(|| chars.by_ref().take(76).collect::<String>())
         .take_while(|s| !s.is_empty())
         .collect::<Vec<_>>()
         .join("\r\n")
@@ -1539,6 +1558,7 @@ 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;
@@ -1547,10 +1567,11 @@ 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};
+    use crate::test_utils::{get_chat_msg, TestContext, TestContextManager};
     #[test]
     fn test_render_email_address() {
         let display_name = "ä space";
@@ -1620,8 +1641,8 @@ mod tests {
     fn test_wrapped_base64_encode() {
         let input = b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
         let output =
-            "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU\r\n\
-             FBQUFBQUFBQQ==";
+            "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\r\n\
+             QUFBQUFBQUFBQQ==";
         assert_eq!(wrapped_base64_encode(input), output);
     }
 
@@ -2199,7 +2220,11 @@ mod tests {
         assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 0);
 
         let part = payload.next().unwrap();
-        assert_eq!(part.match_indices("multipart/mixed").count(), 1);
+        assert_eq!(
+            part.match_indices("multipart/mixed; protected-headers=\"v1\"")
+                .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);
@@ -2311,4 +2336,37 @@ 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(())
+    }
 }