test: test_set_get_group_image(): Log more debug info

There was a recent failure: https://github.com/deltachat/deltachat-core-rust/actions/runs/6413378410/job/17412334267?pr=4789

>       assert msg1.is_system_message()  # Member added
E       AssertionError: assert False
E        +  where False = <bound method Message.is_system_message of <Message incoming sys=False 'hi' id=12 sender=10/45n2p@ci.testrun.org chat=13/hello>>()

Maybe a message reordering happened, but i have no idea why. Let's add more logs to be sure the
"Member added" message isn't just lost.

.github/workflows/ci.yml

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

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

@@ -26,26 +26,35 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      # 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 ziglang and wheel
-        run: pip install wheel ziglang==0.11.0
-
-      - name: Build deltachat-rpc-server binaries
+      - name: Build
         run: sh scripts/zig-rpc-server.sh
 
-      - name: Build deltachat-rpc-server Python wheels and source package
-        run: scripts/wheel-rpc-server.py
-
-      - name: Upload dist directory
+      - name: Upload x86_64 binary
         uses: actions/upload-artifact@v3
         with:
-          name: dist
-          path: dist/
+          name: deltachat-rpc-server-x86_64
+          path: target/x86_64-unknown-linux-musl/release/deltachat-rpc-server
+          if-no-files-found: error
+
+      - name: Upload i686 binary
+        uses: actions/upload-artifact@v3
+        with:
+          name: deltachat-rpc-server-i686
+          path: target/i686-unknown-linux-musl/release/deltachat-rpc-server
+          if-no-files-found: error
+
+      - name: Upload aarch64 binary
+        uses: actions/upload-artifact@v3
+        with:
+          name: deltachat-rpc-server-aarch64
+          path: target/aarch64-unknown-linux-musl/release/deltachat-rpc-server
+          if-no-files-found: error
+
+      - name: Upload armv7 binary
+        uses: actions/upload-artifact@v3
+        with:
+          name: deltachat-rpc-server-armv7
+          path: target/armv7-unknown-linux-musleabihf/release/deltachat-rpc-server
           if-no-files-found: error
 
   build_windows:
@@ -107,29 +116,15 @@ jobs:
       contents: write
     runs-on: "ubuntu-latest"
     steps:
-      - name: Download Linux binaries
-        uses: actions/download-artifact@v3
-        with:
-          name: dist
-          path: dist/
+      - name: Download built binaries
+        uses: "actions/download-artifact@v3"
 
-      - name: Download win32 binary
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-win32.exe
-          path: dist/deltachat-rpc-server-win32.exe
-
-      - name: Download win64 binary
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-win64.exe
-          path: dist/deltachat-rpc-server-win32.exe
-
-      - name: Download macOS binary
-        uses: actions/download-artifact@v3
-        with:
-          name: deltachat-rpc-server-x86_64-macos
-          path: dist/deltachat-rpc-server-x86_64-macos
+      - name: Compose 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
 
       - name: List downloaded artifacts
         run: ls -l dist/

.gitignore

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

CHANGELOG.md

@@ -1,67 +1,5 @@
 # Changelog
 
-## [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
@@ -2941,5 +2879,3 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.123.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.122.0...v1.123.0
 [1.124.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.123.0...v1.124.0
 [1.124.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.124.0...v1.124.1
-[1.125.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.124.1...v1.125.0
-[1.126.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.125.0...v1.126.0

Cargo.lock

@@ -221,9 +221,9 @@ dependencies = [
 
 [[package]]
 name = "async-imap"
-version = "0.9.2"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "936c1b580be4373b48c9c687e0c79285441664398354df28d0860087cac0c069"
+checksum = "b538b767cbf9c162a6c5795d4b932bd2c20ba10b5a91a94d2b2b6886c1dce6a8"
 dependencies = [
  "async-channel",
  "base64 0.21.2",
@@ -1103,7 +1103,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat"
-version = "1.126.0"
+version = "1.124.1"
 dependencies = [
  "ansi_term",
  "anyhow",
@@ -1179,7 +1179,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-jsonrpc"
-version = "1.126.0"
+version = "1.124.1"
 dependencies = [
  "anyhow",
  "async-channel",
@@ -1203,7 +1203,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-repl"
-version = "1.126.0"
+version = "1.124.1"
 dependencies = [
  "ansi_term",
  "anyhow",
@@ -1218,7 +1218,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat-rpc-server"
-version = "1.126.0"
+version = "1.124.1"
 dependencies = [
  "anyhow",
  "deltachat",
@@ -1243,7 +1243,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat_ffi"
-version = "1.126.0"
+version = "1.124.1"
 dependencies = [
  "anyhow",
  "deltachat",

Cargo.toml

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

deltachat-ffi/Cargo.toml

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

deltachat-ffi/deltachat.h

@@ -492,9 +492,6 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  * - `fetch_existing_msgs` = 1=fetch most recent existing messages on configure (default),
  *                    0=do not fetch existing messages on configure.
  *                    In both cases, existing recipients are added to the contact database.
- * - `disable_idle` = 1=disable IMAP IDLE even if the server supports it,
- *                    0=use IMAP IDLE if the server supports it.
- *                    This is a developer option used for testing polling used as an IDLE fallback.
  * - `download_limit` = Messages up to this number of bytes are downloaded automatically.
  *                    For larger messages, only the header is downloaded and a placeholder is shown.
  *                    These messages can be downloaded fully using dc_download_full_msg() later.
@@ -503,9 +500,6 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    to not mess up with non-delivery-reports or read-receipts.
  *                    0=no limit (default).
  *                    Changes affect future messages only.
- * - `gossip_period` = How often to gossip Autocrypt keys in chats with multiple recipients, in
- *                    seconds. 2 days by default.
- *                    This is not supposed to be changed by UIs and only used for testing.
  * - `ui.*`         = All keys prefixed by `ui.` can be used by the user-interfaces for system-specific purposes.
  *                    The prefix should be followed by the system and maybe subsystem,
  *                    e.g. `ui.desktop.foo`, `ui.desktop.linux.bar`, `ui.android.foo`, `ui.dc40.bar`, `ui.bot.simplebot.baz`.
@@ -884,8 +878,7 @@ int             dc_preconfigure_keypair        (dc_context_t* context, const cha
  *     - if the flag DC_GCL_ADD_ALLDONE_HINT is set, DC_CHAT_ID_ALLDONE_HINT
  *       is added as needed.
  * @param query_str An optional query for filtering the list. Only chats matching this query
- *     are returned. Give NULL for no filtering. When `is:unread` is contained in the query,
- *     the chatlist is filtered such that only chats with unread messages show up.
+ *     are returned. Give NULL for no filtering.
  * @param query_id An optional contact ID for filtering the list. Only chats including this contact ID
  *     are returned. Give 0 for no filtering.
  * @return A chatlist as an dc_chatlist_t object.
@@ -1718,12 +1711,24 @@ uint32_t        dc_create_group_chat         (dc_context_t* context, int protect
  * Create a new broadcast list.
  *
  * Broadcast lists are similar to groups on the sending device,
- * however, recipients get the messages in a read-only chat
- * and will see who the other members are.
+ * however, recipients get the messages in normal one-to-one chats
+ * and will not be aware of other members.
  *
- * For historical reasons, this function does not take a name directly,
- * instead you have to set the name using dc_set_chat_name()
- * after creating the broadcast list.
+ * Replies to broadcasts go only to the sender
+ * and not to all broadcast recipients.
+ * Moreover, replies will not appear in the broadcast list
+ * but in the one-to-one chat with the person answering.
+ *
+ * The name and the image of the broadcast list is set automatically
+ * and is visible to the sender only.
+ * Not asking for these data allows more focused creation
+ * and we bypass the question who will get which data.
+ * Also, many users will have at most one broadcast list
+ * so, a generic name and image is sufficient at the first place.
+ *
+ * Later on, however, the name can be changed using dc_set_chat_name().
+ * The image cannot be changed to have a unique, recognizable icon in the chat lists.
+ * All in all, this is also what other messengers are doing here.
  *
  * @memberof dc_context_t
  * @param context The context object.
@@ -2266,7 +2271,8 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
  *   the backup is not encrypted.
  *   The backup contains all contacts, chats, images and other data and device independent settings.
  *   The backup does not contain device dependent settings as ringtones or LED notification settings.
- *   The name of the backup is `delta-chat-backup-<day>-<number>-<addr>.tar`.
+ *   The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
+ *   the format is `delta-chat-<day>-<number>.tar`
  *
  * - **DC_IMEX_IMPORT_BACKUP** (12) - `param1` is the file (not: directory) to import. `param2` is the passphrase.
  *   The file is normally created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
@@ -3950,7 +3956,7 @@ int64_t          dc_msg_get_received_timestamp (const dc_msg_t* msg);
  * Get the message time used for sorting.
  * This function returns the timestamp that is used for sorting the message
  * into lists as returned e.g. by dc_get_chat_msgs().
- * This may be the received time, the sending time or another time.
+ * This may be the reveived time, the sending time or another time.
  *
  * To get the receiving time, use dc_msg_get_received_timestamp().
  * To get the sending time, use dc_msg_get_timestamp().

deltachat-jsonrpc/Cargo.toml

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

deltachat-jsonrpc/src/api/mod.rs

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

deltachat-jsonrpc/typescript/package.json

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

deltachat-jsonrpc/typescript/test/online.ts

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

deltachat-repl/Cargo.toml

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

deltachat-repl/src/cmdline.rs

@@ -138,7 +138,11 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
         /* import a directory */
         let dir_name = std::path::Path::new(&real_spec);
         let dir = fs::read_dir(dir_name).await;
-        if let Ok(mut dir) = dir {
+        if dir.is_err() {
+            error!(context, "Import: Cannot open directory \"{}\".", &real_spec,);
+            return false;
+        } else {
+            let mut dir = dir.unwrap();
             while let Ok(Some(entry)) = dir.next_entry().await {
                 let name_f = entry.file_name();
                 let name = name_f.to_string_lossy();
@@ -150,9 +154,6 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
                     }
                 }
             }
-        } else {
-            error!(context, "Import: Cannot open directory \"{}\".", &real_spec);
-            return false;
         }
     }
     println!("Import: {} items read from \"{}\".", read_cnt, &real_spec);

deltachat-rpc-client/pyproject.toml

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

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

@@ -3,6 +3,7 @@ import logging
 from typing import (
     TYPE_CHECKING,
     Callable,
+    Coroutine,
     Dict,
     Iterable,
     Optional,
@@ -91,7 +92,7 @@ class Client:
         """Process events forever."""
         self.run_until(lambda _: False)
 
-    def run_until(self, func: Callable[[AttrDict], bool]) -> AttrDict:
+    def run_until(self, func: Callable[[AttrDict], Union[bool, Coroutine]]) -> AttrDict:
         """Process events until the given callable evaluates to True.
 
         The callable should accept an AttrDict object representing the

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

@@ -54,6 +54,7 @@ class ACFactory:
         account.start_io()
         while True:
             event = account.wait_for_event()
+            print(event)
             if event.type == EventType.IMAP_INBOX_IDLE:
                 break
         return account

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

@@ -2,7 +2,6 @@ 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
@@ -36,24 +35,12 @@ class Rpc:
         self.events_thread: Thread
 
     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.process = subprocess.Popen(
+            "deltachat-rpc-server",
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            **self._kwargs,
+        )
         self.id = 0
         self.event_queues = {}
         self.request_events = {}
@@ -72,7 +59,7 @@ class Rpc:
         self.closing = True
         self.stop_io_for_all_accounts()
         self.events_thread.join()
-        self.process.stdin.close()
+        self.process.terminate()
         self.reader_thread.join()
         self.request_queue.put(None)
         self.writer_thread.join()
@@ -97,7 +84,7 @@ class Rpc:
                     self.request_results[response_id] = response
                     event.set()
                 else:
-                    logging.warning("Got a response without ID: %s", response)
+                    print(response)
         except Exception:
             # Log an exception if the reader loop dies.
             logging.exception("Exception in the reader loop")

deltachat-rpc-server/Cargo.toml

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

draft/aeap-mvp.md

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

node/lib/context.ts

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

package.json

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

python/src/deltachat/account.py

@@ -617,18 +617,18 @@ class Account:
     # meta API for start/stop and event based processing
     #
 
-    def run_account(self, addr=None, password=None, account_plugins=None, show_ffi=False, displayname=None):
+    def run_account(self, addr=None, password=None, account_plugins=None, show_ffi=False):
+        from .events import FFIEventLogger
+
         """get the account running, configure it if necessary. add plugins if provided.
 
         :param addr: the email address of the account
         :param password: the password of the account
         :param account_plugins: a list of plugins to add
         :param show_ffi: show low level ffi events
-        :param displayname: the display name of the account
         """
-        from .events import FFIEventLogger
-
         if show_ffi:
+            self.set_config("displayname", "bot")
             log = FFIEventLogger(self)
             self.add_account_plugin(log)
 
@@ -644,8 +644,6 @@ class Account:
             configtracker = self.configure()
             configtracker.wait_finish()
 
-        if displayname:
-            self.set_config("displayname", displayname)
         # start IO threads and configure if necessary
         self.start_io()
 

python/tests/test_0_complex_or_slow.py

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

python/tests/test_1_online.py

@@ -1698,10 +1698,12 @@ def test_qr_new_group_unblocked(acfactory, lp):
 
     ac1_new_chat = ac1.create_group_chat("Another group")
     ac1_new_chat.add_contact(ac2)
+    ac1_new_chat.send_text("Hello!")
+
     # Receive "Member added" message.
     ac2._evtracker.wait_next_incoming_message()
 
-    ac1_new_chat.send_text("Hello!")
+    # Receive "Hello!" message.
     ac2_msg = ac2._evtracker.wait_next_incoming_message()
     assert ac2_msg.text == "Hello!"
     assert ac2_msg.chat.is_contact_request()
@@ -1924,16 +1926,17 @@ 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")
+    lp.sec("ac2: receive messages from ac1")
+    msg1 = ac2._evtracker.wait_next_incoming_message()
+    print(f"ac2: msg1={msg1}")
+    # DEBUG: Postpone assertions to have more info in the log.
     msg2 = ac2._evtracker.wait_next_incoming_message()
+    print(f"ac2: msg2={msg2}")
+    assert msg1.is_system_message()  # Member added
     assert msg2.text == "hi"
     assert msg1.chat.id == msg2.chat.id
 

release-date.in

@@ -1 +1 @@
-2023-10-22
+2023-10-05

scripts/README.md

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

scripts/make-python-testenv.sh

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

scripts/wheel-rpc-server.py

@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-"""Build Python wheels for deltachat-rpc-server.
-Run scripts/zig-rpc-server.sh first."""
-from pathlib import Path
-from wheel.wheelfile import WheelFile
-import tomllib
-import tarfile
-from io import BytesIO
-
-
-def metadata_contents(version):
-    return f"""Metadata-Version: 2.1
-Name: deltachat-rpc-server
-Version: {version}
-Summary: Delta Chat JSON-RPC server
-"""
-
-
-SETUP_PY = """
-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",
-            ],
-            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"]},
-)
-"""
-
-
-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",
-            """[build-system]
-requires = ["setuptools==68.2.2", "pip"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "deltachat-rpc-server"
-version = "1.125.0"
-
-[project.scripts]
-deltachat-rpc-server = "deltachat_rpc_server:main"
-""",
-        )
-        pack("setup.py", SETUP_PY)
-        pack("src/deltachat_rpc_server/__init__.py", "")
-
-
-def build_wheel(version, binary, tag):
-    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")
-        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)
-""",
-        )
-
-        wheel.write(
-            binary,
-            "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",
-    )
-
-
-main()

scripts/zig-cc

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

scripts/zig-musl-check.sh

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

scripts/zig-rpc-server.sh

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

spec.md

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

src/chat.rs

@@ -2337,7 +2337,7 @@ pub async fn send_msg_sync(context: &Context, chat_id: ChatId, msg: &mut Message
 }
 
 async fn send_msg_inner(context: &Context, chat_id: ChatId, msg: &mut Message) -> Result<MsgId> {
-    // protect all system messages against RTLO attacks
+    // protect all system messages againts RTLO attacks
     if msg.is_system_message() {
         msg.text = strip_rtlo_characters(&msg.text);
     }
@@ -6094,40 +6094,22 @@ mod tests {
             get_chat_contacts(&alice, chat_bob.id).await?.pop().unwrap(),
         )
         .await?;
-        set_chat_name(&alice, broadcast_id, "Broadcast list").await?;
-        {
-            let chat = Chat::load_from_db(&alice, broadcast_id).await?;
-            assert_eq!(chat.typ, Chattype::Broadcast);
-            assert_eq!(chat.name, "Broadcast list");
-            assert!(!chat.is_self_talk());
+        let chat = Chat::load_from_db(&alice, broadcast_id).await?;
+        assert_eq!(chat.typ, Chattype::Broadcast);
+        assert_eq!(chat.name, stock_str::broadcast_list(&alice).await);
+        assert!(!chat.is_self_talk());
 
-            send_text_msg(&alice, broadcast_id, "ola!".to_string()).await?;
-            let msg = alice.get_last_msg().await;
-            assert_eq!(msg.chat_id, chat.id);
-        }
+        send_text_msg(&alice, broadcast_id, "ola!".to_string()).await?;
+        let msg = alice.get_last_msg().await;
+        assert_eq!(msg.chat_id, chat.id);
 
-        {
-            let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
-            assert_eq!(msg.get_text(), "ola!");
-            assert_eq!(msg.subject, "Broadcast list");
-            assert!(!msg.get_showpadlock()); // avoid leaking recipients in encryption data
-            let chat = Chat::load_from_db(&bob, msg.chat_id).await?;
-            assert_eq!(chat.typ, Chattype::Mailinglist);
-            assert_ne!(chat.id, chat_bob.id);
-            assert_eq!(chat.name, "Broadcast list");
-            assert!(!chat.is_self_talk());
-        }
-
-        {
-            // Alice changes the name:
-            set_chat_name(&alice, broadcast_id, "My great broadcast").await?;
-            let sent = alice.send_text(broadcast_id, "I changed the title!").await;
-
-            let msg = bob.recv_msg(&sent).await;
-            assert_eq!(msg.subject, "Re: My great broadcast");
-            let bob_chat = Chat::load_from_db(&bob, msg.chat_id).await?;
-            assert_eq!(bob_chat.name, "My great broadcast");
-        }
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
+        assert_eq!(msg.get_text(), "ola!");
+        assert!(!msg.get_showpadlock()); // avoid leaking recipients in encryption data
+        let chat = Chat::load_from_db(&bob, msg.chat_id).await?;
+        assert_eq!(chat.typ, Chattype::Single);
+        assert_eq!(chat.id, chat_bob.id);
+        assert!(!chat.is_self_talk());
 
         Ok(())
     }

src/chatlist.rs

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

src/config.rs

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

src/contact.rs

@@ -812,11 +812,7 @@ impl Contact {
         let mut ret = Vec::new();
         let flag_verified_only = (listflags & DC_GCL_VERIFIED_ONLY) != 0;
         let flag_add_self = (listflags & DC_GCL_ADD_SELF) != 0;
-        let minimal_origin = if context.get_config_bool(Config::Bot).await? {
-            Origin::Unknown
-        } else {
-            Origin::IncomingReplyTo
-        };
+
         if flag_verified_only || query.is_some() {
             let s3str_like_cmd = format!("%{}%", query.unwrap_or(""));
             context
@@ -836,7 +832,7 @@ impl Contact {
                     ),
                     rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
                         ContactId::LAST_SPECIAL,
-                        minimal_origin,
+                        Origin::IncomingReplyTo,
                         s3str_like_cmd,
                         s3str_like_cmd,
                         if flag_verified_only { 0i32 } else { 1i32 }
@@ -886,10 +882,10 @@ impl Contact {
                  ORDER BY last_seen DESC, id DESC;",
                         sql::repeat_vars(self_addrs.len())
                     ),
-                    rusqlite::params_from_iter(
-                        params_iter(&self_addrs)
-                            .chain(params_slice![ContactId::LAST_SPECIAL, minimal_origin]),
-                    ),
+                    rusqlite::params_from_iter(params_iter(&self_addrs).chain(params_slice![
+                        ContactId::LAST_SPECIAL,
+                        Origin::IncomingReplyTo
+                    ])),
                     |row| row.get::<_, ContactId>(0),
                     |ids| {
                         for id in ids {
@@ -1265,7 +1261,7 @@ impl Contact {
             return Ok(Some(ContactId::SELF));
         }
 
-        match Contact::lookup_id_by_addr(context, &verifier_addr, Origin::Unknown).await? {
+        match Contact::lookup_id_by_addr(context, &verifier_addr, Origin::AddressBook).await? {
             Some(contact_id) => Ok(Some(contact_id)),
             None => {
                 let addr = &self.addr;

src/context.rs

@@ -38,7 +38,7 @@ use crate::tools::{duration_to_str, time};
 ///
 /// # Examples
 ///
-/// Creating a new unencrypted database:
+/// Creating a new unecrypted database:
 ///
 /// ```
 /// # let rt = tokio::runtime::Runtime::new().unwrap();
@@ -579,7 +579,6 @@ impl Context {
         let mdns_enabled = self.get_config_int(Config::MdnsEnabled).await?;
         let bcc_self = self.get_config_int(Config::BccSelf).await?;
         let send_sync_msgs = self.get_config_int(Config::SendSyncMsgs).await?;
-        let disable_idle = self.get_config_bool(Config::DisableIdle).await?;
 
         let prv_key_cnt = self.sql.count("SELECT COUNT(*) FROM keypairs;", ()).await?;
 
@@ -692,7 +691,6 @@ impl Context {
         );
         res.insert("bcc_self", bcc_self.to_string());
         res.insert("send_sync_msgs", send_sync_msgs.to_string());
-        res.insert("disable_idle", disable_idle.to_string());
         res.insert("private_key_count", prv_key_cnt.to_string());
         res.insert("public_key_count", pub_key_cnt.to_string());
         res.insert("fingerprint", fingerprint_str);
@@ -754,6 +752,7 @@ impl Context {
                 .await?
                 .to_string(),
         );
+
         res.insert(
             "debug_logging",
             self.get_config_int(Config::DebugLogging).await?.to_string(),
@@ -762,10 +761,6 @@ impl Context {
             "last_msg_id",
             self.get_config_int(Config::LastMsgId).await?.to_string(),
         );
-        res.insert(
-            "gossip_period",
-            self.get_config_int(Config::GossipPeriod).await?.to_string(),
-        );
 
         let elapsed = self.creation_time.elapsed();
         res.insert("uptime", duration_to_str(elapsed.unwrap_or_default()));

src/download.rs

@@ -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`.
-pub(crate) const MIN_DOWNLOAD_LIMIT: u32 = 32768;
+const MIN_DOWNLOAD_LIMIT: u32 = 32768;
 
 /// If a message is downloaded only partially
 /// and `delete_server_after` is set to small timeouts (eg. "at once"),

src/imap.rs

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

src/imap/idle.rs

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

src/imex.rs

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

src/mimefactory.rs

@@ -359,10 +359,9 @@ impl<'a> MimeFactory<'a> {
     async fn should_do_gossip(&self, context: &Context) -> Result<bool> {
         match &self.loaded {
             Loaded::Message { chat } => {
-                // beside key- and member-changes, force a periodic re-gossip.
+                // beside key- and member-changes, force re-gossip every 48 hours
                 let gossiped_timestamp = chat.id.get_gossiped_timestamp(context).await?;
-                let gossip_period = context.get_config_i64(Config::GossipPeriod).await?;
-                if time() >= gossiped_timestamp + gossip_period {
+                if time() > gossiped_timestamp + (2 * 24 * 60 * 60) {
                     Ok(true)
                 } else {
                     let cmd = self.msg.param.get_cmd();
@@ -415,9 +414,7 @@ impl<'a> MimeFactory<'a> {
                     return Ok(self.msg.subject.clone());
                 }
 
-                if (chat.typ == Chattype::Group || chat.typ == Chattype::Broadcast)
-                    && quoted_msg_subject.is_none_or_empty()
-                {
+                if chat.typ == Chattype::Group && quoted_msg_subject.is_none_or_empty() {
                     let re = if self.in_reply_to.is_empty() {
                         ""
                     } else {
@@ -426,13 +423,15 @@ impl<'a> MimeFactory<'a> {
                     return Ok(format!("{}{}", re, chat.name));
                 }
 
-                let parent_subject = if quoted_msg_subject.is_none_or_empty() {
-                    chat.param.get(Param::LastSubject)
-                } else {
-                    quoted_msg_subject.as_deref()
-                };
-                if let Some(last_subject) = parent_subject {
-                    return Ok(format!("Re: {}", remove_subject_prefix(last_subject)));
+                if chat.typ != Chattype::Broadcast {
+                    let parent_subject = if quoted_msg_subject.is_none_or_empty() {
+                        chat.param.get(Param::LastSubject)
+                    } else {
+                        quoted_msg_subject.as_deref()
+                    };
+                    if let Some(last_subject) = parent_subject {
+                        return Ok(format!("Re: {}", remove_subject_prefix(last_subject)));
+                    }
                 }
 
                 let self_name = &match context.get_config(Config::Displayname).await? {
@@ -594,15 +593,6 @@ impl<'a> MimeFactory<'a> {
             ));
         }
 
-        if let Loaded::Message { chat } = &self.loaded {
-            if chat.typ == Chattype::Broadcast {
-                headers.protected.push(Header::new(
-                    "List-ID".into(),
-                    format!("{} <{}>", chat.name, chat.grpid),
-                ));
-            }
-        }
-
         // Non-standard headers.
         headers
             .unprotected
@@ -2341,7 +2331,7 @@ mod tests {
         // 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.
+        // decoded_data to check presense 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?;

src/mimeparser.rs

@@ -110,7 +110,7 @@ pub(crate) struct MimeMessage {
 
     /// The decrypted, raw mime structure.
     ///
-    /// This is non-empty iff `is_mime_modified` and the message was actually encrypted. It is used
+    /// This is non-empty only if the message was actually encrypted.  It is used
     /// for e.g. late-parsing HTML.
     pub decoded_data: Vec<u8>,
 
@@ -123,6 +123,23 @@ pub(crate) enum AvatarAction {
     Change(String),
 }
 
+#[derive(Debug, PartialEq)]
+pub(crate) enum MailinglistType {
+    /// The message belongs to a mailing list and has a `ListId:`-header
+    /// that should be used to get a unique id.
+    ListIdBased,
+
+    /// The message belongs to a mailing list, but there is no `ListId:`-header;
+    /// `Sender:`-header should be used to get a unique id.
+    /// This method is used by implementations as Majordomo.
+    /// Note, that the `Sender:` header alone is not sufficient to detect these lists,
+    /// `get_mailinglist_type()` check additional conditions therefore.
+    SenderBased,
+
+    /// The message does not belong to a mailing list.
+    None,
+}
+
 /// System message type.
 #[derive(
     Debug, Default, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, ToSql, FromSql,
@@ -1323,28 +1340,26 @@ impl MimeMessage {
         self.parts.push(part);
     }
 
-    pub(crate) fn get_mailinglist_header(&self) -> Option<&str> {
-        if let Some(list_id) = self.get_header(HeaderDef::ListId) {
-            // The message belongs to a mailing list and has a `ListId:`-header
-            // that should be used to get a unique id.
-            return Some(list_id);
-        } else if let Some(sender) = self.get_header(HeaderDef::Sender) {
+    pub(crate) fn get_mailinglist_type(&self) -> MailinglistType {
+        if self.get_header(HeaderDef::ListId).is_some() {
+            return MailinglistType::ListIdBased;
+        } else if self.get_header(HeaderDef::Sender).is_some() {
             // the `Sender:`-header alone is no indicator for mailing list
             // as also used for bot-impersonation via `set_override_sender_name()`
             if let Some(precedence) = self.get_header(HeaderDef::Precedence) {
                 if precedence == "list" || precedence == "bulk" {
-                    // The message belongs to a mailing list, but there is no `ListId:`-header;
-                    // `Sender:`-header is be used to get a unique id.
-                    // This method is used by implementations as Majordomo.
-                    return Some(sender);
+                    return MailinglistType::SenderBased;
                 }
             }
         }
-        None
+        MailinglistType::None
     }
 
     pub(crate) fn is_mailinglist_message(&self) -> bool {
-        self.get_mailinglist_header().is_some()
+        match self.get_mailinglist_type() {
+            MailinglistType::ListIdBased | MailinglistType::SenderBased => true,
+            MailinglistType::None => false,
+        }
     }
 
     pub fn repl_msg_by_error(&mut self, error_msg: &str) {
@@ -1878,7 +1893,7 @@ fn get_mime_type(
             } else {
                 // Enacapsulated messages, see <https://www.w3.org/Protocols/rfc1341/7_3_Message.html>
                 // Also used as part "message/disposition-notification" of "multipart/report", which, however, will
-                // be handled separately.
+                // be handled separatedly.
                 // I've not seen any messages using this, so we do not attach these parts (maybe they're used to attach replies,
                 // which are unwanted at all).
                 // For now, we skip these parts at all; if desired, we could return DcMimeType::File/DC_MSG_File

src/peerstate.rs

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

src/receive_imf.rs

@@ -28,7 +28,9 @@ use crate::log::LogExt;
 use crate::message::{
     self, rfc724_mid_exists, Message, MessageState, MessengerMessage, MsgId, Viewtype,
 };
-use crate::mimeparser::{parse_message_ids, AvatarAction, MimeMessage, SystemMessage};
+use crate::mimeparser::{
+    parse_message_ids, AvatarAction, MailinglistType, MimeMessage, SystemMessage,
+};
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateKeyType, PeerstateVerifiedStatus};
 use crate::reaction::{set_msg_reaction, Reaction};
@@ -75,24 +77,6 @@ pub async fn receive_imf(
     let mail = parse_mail(imf_raw).context("can't parse mail")?;
     let rfc724_mid =
         imap::prefetch_get_message_id(&mail.headers).unwrap_or_else(imap::create_message_id);
-    if let Some(download_limit) = context.download_limit().await? {
-        let download_limit: usize = download_limit.try_into()?;
-        if imf_raw.len() > download_limit {
-            let head = std::str::from_utf8(imf_raw)?
-                .split("\r\n\r\n")
-                .next()
-                .context("No empty line in the message")?;
-            return receive_imf_inner(
-                context,
-                &rfc724_mid,
-                head.as_bytes(),
-                seen,
-                Some(imf_raw.len().try_into()?),
-                false,
-            )
-            .await;
-        }
-    }
     receive_imf_inner(context, &rfc724_mid, imf_raw, seen, None, false).await
 }
 
@@ -594,7 +578,6 @@ async fn add_parts(
             if let Some((new_chat_id, new_chat_id_blocked)) = create_or_lookup_group(
                 context,
                 mime_parser,
-                is_partial_download.is_some(),
                 if test_normal_chat.is_none() {
                     allow_creation
                 } else {
@@ -652,23 +635,45 @@ async fn add_parts(
 
         if chat_id.is_none() {
             // check if the message belongs to a mailing list
-            if let Some(mailinglist_header) = mime_parser.get_mailinglist_header() {
-                if let Some((new_chat_id, new_chat_id_blocked)) = create_or_lookup_mailinglist(
-                    context,
-                    allow_creation,
-                    mailinglist_header,
-                    mime_parser,
-                )
-                .await?
-                {
-                    chat_id = Some(new_chat_id);
-                    chat_id_blocked = new_chat_id_blocked;
+            match mime_parser.get_mailinglist_type() {
+                MailinglistType::ListIdBased => {
+                    if let Some(list_id) = mime_parser.get_header(HeaderDef::ListId) {
+                        if let Some((new_chat_id, new_chat_id_blocked)) =
+                            create_or_lookup_mailinglist(
+                                context,
+                                allow_creation,
+                                list_id,
+                                mime_parser,
+                            )
+                            .await?
+                        {
+                            chat_id = Some(new_chat_id);
+                            chat_id_blocked = new_chat_id_blocked;
+                        }
+                    }
                 }
+                MailinglistType::SenderBased => {
+                    if let Some(sender) = mime_parser.get_header(HeaderDef::Sender) {
+                        if let Some((new_chat_id, new_chat_id_blocked)) =
+                            create_or_lookup_mailinglist(
+                                context,
+                                allow_creation,
+                                sender,
+                                mime_parser,
+                            )
+                            .await?
+                        {
+                            chat_id = Some(new_chat_id);
+                            chat_id_blocked = new_chat_id_blocked;
+                        }
+                    }
+                }
+                MailinglistType::None => {}
             }
         }
 
         if let Some(chat_id) = chat_id {
-            apply_mailinglist_changes(context, mime_parser, sent_timestamp, chat_id).await?;
+            apply_mailinglist_changes(context, mime_parser, chat_id).await?;
         }
 
         // if contact renaming is prevented (for mailinglists and bots),
@@ -799,7 +804,6 @@ async fn add_parts(
                 if let Some((new_chat_id, new_chat_id_blocked)) = create_or_lookup_group(
                     context,
                     mime_parser,
-                    is_partial_download.is_some(),
                     allow_creation,
                     Blocked::Not,
                     from_id,
@@ -1182,8 +1186,8 @@ INSERT INTO msgs
   )
 ON CONFLICT (id) DO UPDATE
 SET rfc724_mid=excluded.rfc724_mid, chat_id=excluded.chat_id,
-    from_id=excluded.from_id, to_id=excluded.to_id, timestamp_sent=excluded.timestamp_sent,
-    type=excluded.type, msgrmsg=excluded.msgrmsg,
+    from_id=excluded.from_id, to_id=excluded.to_id, timestamp=excluded.timestamp, timestamp_sent=excluded.timestamp_sent,
+    timestamp_rcvd=excluded.timestamp_rcvd, type=excluded.type, state=excluded.state, msgrmsg=excluded.msgrmsg,
     txt=excluded.txt, subject=excluded.subject, txt_raw=excluded.txt_raw, param=excluded.param,
     bytes=excluded.bytes, mime_headers=excluded.mime_headers,
     mime_compressed=excluded.mime_compressed, mime_in_reply_to=excluded.mime_in_reply_to,
@@ -1496,7 +1500,6 @@ async fn is_probably_private_reply(
 async fn create_or_lookup_group(
     context: &Context,
     mime_parser: &mut MimeMessage,
-    is_partial_download: bool,
     allow_creation: bool,
     create_blocked: Blocked,
     from_id: ContactId,
@@ -1627,7 +1630,7 @@ async fn create_or_lookup_group(
 
     if let Some(chat_id) = chat_id {
         Ok(Some((chat_id, chat_id_blocked)))
-    } else if is_partial_download || mime_parser.decrypting_failed {
+    } else if mime_parser.decrypting_failed {
         // It is possible that the message was sent to a valid,
         // yet unknown group, which was rejected because
         // Chat-Group-Name, which is in the encrypted part, was
@@ -1897,8 +1900,6 @@ async fn apply_group_changes(
     Ok(better_msg)
 }
 
-static LIST_ID_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(.+)<(.+)>$").unwrap());
-
 /// Create or lookup a mailing list chat.
 ///
 /// `list_id_header` contains the Id that must be used for the mailing list
@@ -1915,71 +1916,23 @@ async fn create_or_lookup_mailinglist(
     list_id_header: &str,
     mime_parser: &MimeMessage,
 ) -> Result<Option<(ChatId, Blocked)>> {
-    let listid = match LIST_ID_REGEX.captures(list_id_header) {
-        Some(cap) => cap[2].trim().to_string(),
-        None => list_id_header
-            .trim()
-            .trim_start_matches('<')
-            .trim_end_matches('>')
-            .to_string(),
+    static LIST_ID: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(.+)<(.+)>$").unwrap());
+    let (mut name, listid) = match LIST_ID.captures(list_id_header) {
+        Some(cap) => (cap[1].trim().to_string(), cap[2].trim().to_string()),
+        None => (
+            "".to_string(),
+            list_id_header
+                .trim()
+                .trim_start_matches('<')
+                .trim_end_matches('>')
+                .to_string(),
+        ),
     };
 
     if let Some((chat_id, _, blocked)) = chat::get_chat_id_by_grpid(context, &listid).await? {
         return Ok(Some((chat_id, blocked)));
     }
 
-    let name = compute_mailinglist_name(list_id_header, &listid, mime_parser);
-
-    if allow_creation {
-        // list does not exist but should be created
-        let param = mime_parser.list_post.as_ref().map(|list_post| {
-            let mut p = Params::new();
-            p.set(Param::ListPost, list_post);
-            p.to_string()
-        });
-
-        let is_bot = context.get_config_bool(Config::Bot).await?;
-        let blocked = if is_bot {
-            Blocked::Not
-        } else {
-            Blocked::Request
-        };
-        let chat_id = ChatId::create_multiuser_record(
-            context,
-            Chattype::Mailinglist,
-            &listid,
-            &name,
-            blocked,
-            ProtectionStatus::Unprotected,
-            param,
-        )
-        .await
-        .with_context(|| {
-            format!(
-                "failed to create mailinglist '{}' for grpid={}",
-                &name, &listid
-            )
-        })?;
-
-        chat::add_to_chat_contacts_table(context, chat_id, &[ContactId::SELF]).await?;
-        Ok(Some((chat_id, blocked)))
-    } else {
-        info!(context, "Creating list forbidden by caller.");
-        Ok(None)
-    }
-}
-
-#[allow(clippy::indexing_slicing)]
-fn compute_mailinglist_name(
-    list_id_header: &str,
-    listid: &str,
-    mime_parser: &MimeMessage,
-) -> String {
-    let mut name = match LIST_ID_REGEX.captures(list_id_header) {
-        Some(cap) => cap[1].trim().to_string(),
-        None => "".to_string(),
-    };
-
     // for mailchimp lists, the name in `ListId` is just a long number.
     // a usable name for these lists is in the `From` header
     // and we can detect these lists by a unique `ListId`-suffix.
@@ -2023,14 +1976,50 @@ fn compute_mailinglist_name(
         // 51231231231231231231231232869f58.xing.com -> xing.com
         static PREFIX_32_CHARS_HEX: Lazy<Regex> =
             Lazy::new(|| Regex::new(r"([0-9a-fA-F]{32})\.(.{6,})").unwrap());
-        if let Some(cap) = PREFIX_32_CHARS_HEX.captures(listid) {
+        if let Some(cap) = PREFIX_32_CHARS_HEX.captures(&listid) {
             name = cap[2].to_string();
         } else {
-            name = listid.to_string();
+            name = listid.clone();
         }
     }
 
-    strip_rtlo_characters(&name)
+    if allow_creation {
+        // list does not exist but should be created
+        let param = mime_parser.list_post.as_ref().map(|list_post| {
+            let mut p = Params::new();
+            p.set(Param::ListPost, list_post);
+            p.to_string()
+        });
+
+        let is_bot = context.get_config_bool(Config::Bot).await?;
+        let blocked = if is_bot {
+            Blocked::Not
+        } else {
+            Blocked::Request
+        };
+        let chat_id = ChatId::create_multiuser_record(
+            context,
+            Chattype::Mailinglist,
+            &listid,
+            &name,
+            blocked,
+            ProtectionStatus::Unprotected,
+            param,
+        )
+        .await
+        .with_context(|| {
+            format!(
+                "failed to create mailinglist '{}' for grpid={}",
+                &name, &listid
+            )
+        })?;
+
+        chat::add_to_chat_contacts_table(context, chat_id, &[ContactId::SELF]).await?;
+        Ok(Some((chat_id, blocked)))
+    } else {
+        info!(context, "Creating list forbidden by caller.");
+        Ok(None)
+    }
 }
 
 /// Set ListId param on the contact and ListPost param the chat.
@@ -2039,10 +2028,9 @@ fn compute_mailinglist_name(
 async fn apply_mailinglist_changes(
     context: &Context,
     mime_parser: &MimeMessage,
-    sent_timestamp: i64,
     chat_id: ChatId,
 ) -> Result<()> {
-    let Some(mailinglist_header) = mime_parser.get_mailinglist_header() else {
+    let Some(list_post) = &mime_parser.list_post else {
         return Ok(());
     };
 
@@ -2052,24 +2040,6 @@ async fn apply_mailinglist_changes(
     }
     let listid = &chat.grpid;
 
-    let new_name = compute_mailinglist_name(mailinglist_header, listid, mime_parser);
-    if chat.name != new_name
-        && chat_id
-            .update_timestamp(context, Param::GroupNameTimestamp, sent_timestamp)
-            .await?
-    {
-        info!(context, "Updating listname for chat {chat_id}.");
-        context
-            .sql
-            .execute("UPDATE chats SET name=? WHERE id=?;", (new_name, chat_id))
-            .await?;
-        context.emit_event(EventType::ChatModified(chat_id));
-    }
-
-    let Some(list_post) = &mime_parser.list_post else {
-        return Ok(());
-    };
-
     let list_post = match ContactAddress::new(list_post) {
         Ok(list_post) => list_post,
         Err(err) => {

src/receive_imf/tests.rs

@@ -10,9 +10,8 @@ use crate::chat::{get_chat_msgs, ChatItem, ChatVisibility};
 use crate::chatlist::Chatlist;
 use crate::config::Config;
 use crate::constants::{DC_GCL_FOR_FORWARDING, DC_GCL_NO_SPECIALS};
-use crate::download::{DownloadState, MIN_DOWNLOAD_LIMIT};
 use crate::imap::prefetch_should_download;
-use crate::message::{self, Message};
+use crate::message::Message;
 use crate::test_utils::{get_chat_msg, TestContext, TestContextManager};
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -2974,7 +2973,6 @@ async fn test_auto_accept_for_bots() -> Result<()> {
     let msg = t.get_last_msg().await;
     let chat = chat::Chat::load_from_db(&t, msg.chat_id).await?;
     assert!(!chat.is_contact_request());
-    assert!(Contact::get_all(&t, 0, None).await?.len() == 1);
     Ok(())
 }
 
@@ -3699,114 +3697,3 @@ async fn test_keep_member_list_if_possibly_nomember() -> Result<()> {
     assert!(is_contact_in_chat(&bob, bob_chat_id, bob_alice_contact).await?);
     Ok(())
 }
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_download_later() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = tcm.alice().await;
-    alice.set_config(Config::DownloadLimit, Some("1")).await?;
-    assert_eq!(alice.download_limit().await?, Some(MIN_DOWNLOAD_LIMIT));
-
-    let bob = tcm.bob().await;
-    let bob_chat = bob.create_chat(&alice).await;
-    let text = String::from_utf8(vec![b'a'; MIN_DOWNLOAD_LIMIT as usize])?;
-    let sent_msg = bob.send_text(bob_chat.id, &text).await;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    assert_eq!(msg.state, MessageState::InFresh);
-
-    let hi_msg = tcm.send_recv(&bob, &alice, "hi").await;
-
-    alice.set_config(Config::DownloadLimit, None).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Done);
-    assert_eq!(msg.state, MessageState::InFresh);
-    assert_eq!(alice.get_last_msg_in(msg.chat_id).await.id, hi_msg.id);
-    assert!(msg.timestamp_sort <= hi_msg.timestamp_sort);
-
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_create_group_with_big_msg() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = tcm.alice().await;
-    let bob = tcm.bob().await;
-    let ba_contact = Contact::create(
-        &bob,
-        "alice",
-        &alice.get_config(Config::Addr).await?.unwrap(),
-    )
-    .await?;
-    let file_bytes = include_bytes!("../../test-data/image/screenshot.png");
-
-    let bob_grp_id = create_group_chat(&bob, ProtectionStatus::Unprotected, "Group").await?;
-    add_contact_to_chat(&bob, bob_grp_id, ba_contact).await?;
-    let mut msg = Message::new(Viewtype::Image);
-    msg.set_file_from_bytes(&bob, "a.jpg", file_bytes, None)
-        .await?;
-    let sent_msg = bob.send_msg(bob_grp_id, &mut msg).await;
-    assert!(!msg.get_showpadlock());
-
-    alice.set_config(Config::DownloadLimit, Some("1")).await?;
-    assert_eq!(alice.download_limit().await?, Some(MIN_DOWNLOAD_LIMIT));
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    let alice_grp = Chat::load_from_db(&alice, msg.chat_id).await?;
-    assert_eq!(alice_grp.typ, Chattype::Group);
-    assert_eq!(alice_grp.name, "Group");
-    assert_eq!(
-        chat::get_chat_contacts(&alice, alice_grp.id).await?.len(),
-        2
-    );
-
-    alice.set_config(Config::DownloadLimit, None).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Done);
-    assert_eq!(msg.state, MessageState::InFresh);
-    assert_eq!(msg.viewtype, Viewtype::Image);
-    assert_eq!(msg.chat_id, alice_grp.id);
-    let alice_grp = Chat::load_from_db(&alice, msg.chat_id).await?;
-    assert_eq!(alice_grp.typ, Chattype::Group);
-    assert_eq!(alice_grp.name, "Group");
-    assert_eq!(
-        chat::get_chat_contacts(&alice, alice_grp.id).await?.len(),
-        2
-    );
-
-    let ab_chat_id = tcm.send_recv_accept(&alice, &bob, "hi").await.chat_id;
-    // Now Bob can send encrypted messages to Alice.
-
-    let bob_grp_id = create_group_chat(&bob, ProtectionStatus::Unprotected, "Group1").await?;
-    add_contact_to_chat(&bob, bob_grp_id, ba_contact).await?;
-    let mut msg = Message::new(Viewtype::Image);
-    msg.set_file_from_bytes(&bob, "a.jpg", file_bytes, None)
-        .await?;
-    let sent_msg = bob.send_msg(bob_grp_id, &mut msg).await;
-    assert!(msg.get_showpadlock());
-
-    alice.set_config(Config::DownloadLimit, Some("1")).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Available);
-    // Until fully downloaded, an encrypted message must sit in the 1:1 chat.
-    assert_eq!(msg.chat_id, ab_chat_id);
-
-    alice.set_config(Config::DownloadLimit, None).await?;
-    let msg = alice.recv_msg(&sent_msg).await;
-    assert_eq!(msg.download_state, DownloadState::Done);
-    assert_eq!(msg.state, MessageState::InFresh);
-    assert_eq!(msg.viewtype, Viewtype::Image);
-    assert_ne!(msg.chat_id, ab_chat_id);
-    let alice_grp = Chat::load_from_db(&alice, msg.chat_id).await?;
-    assert_eq!(alice_grp.typ, Chattype::Group);
-    assert_eq!(alice_grp.name, "Group1");
-    assert_eq!(
-        chat::get_chat_contacts(&alice, alice_grp.id).await?.len(),
-        2
-    );
-
-    // The big message must go away from the 1:1 chat.
-    assert_eq!(alice.get_last_msg_in(ab_chat_id).await.text, "hi");
-
-    Ok(())
-}

src/scheduler.rs

@@ -574,19 +574,6 @@ async fn fetch_idle(
                 .await;
         }
 
-        if ctx
-            .get_config_bool(Config::DisableIdle)
-            .await
-            .context("Failed to get disable_idle config")
-            .log_err(ctx)
-            .unwrap_or_default()
-        {
-            info!(ctx, "IMAP IDLE is disabled, going to fake idle.");
-            return connection
-                .fake_idle(ctx, Some(watch_folder), folder_meaning)
-                .await;
-        }
-
         info!(ctx, "IMAP session supports IDLE, using it.");
         match session
             .idle(

src/smtp.rs

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

src/sql.rs

@@ -686,7 +686,6 @@ fn new_connection(path: &Path, passphrase: &str) -> Result<Connection> {
          PRAGMA secure_delete=on;
          PRAGMA busy_timeout = 0; -- fail immediately
          PRAGMA temp_store=memory; -- Avoid SQLITE_IOERR_GETTEMPPATH errors on Android
-         PRAGMA soft_heap_limit = 8388608; -- 8 MiB limit, same as set in Android SQLiteDatabase.
          PRAGMA foreign_keys=on;
          ",
     )?;

src/stock_str.rs

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

src/tools.rs

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