Release 1.88.0

we want to prevent runaway things,
not restrict normal usage too much,
this limit seems to be more reasonable
also for most round-based games.

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ on:
 
 env:
   RUSTFLAGS: -Dwarnings
-
+   
 jobs:
 
   fmt:
@@ -83,13 +83,13 @@ jobs:
             rust: 1.61.0
             python: false # Python bindings compilation on Windows is not supported.
 
-          # Minimum Supported Rust Version = 1.56.0
+          # Minimum Supported Rust Version = 1.56.1
           #
           # Minimum Supported Python Version = 3.7
           # This is the minimum version for which manylinux Python wheels are
           # built.
           - os: ubuntu-latest
-            rust: 1.56.0
+            rust: 1.56.1
             python: 3.7
     runs-on: ${{ matrix.os }}
     steps:
@@ -118,7 +118,7 @@ jobs:
 
     - name: install python
       if: ${{ matrix.python }}
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python }}
 
@@ -141,3 +141,18 @@ jobs:
         DCC_RS_DEV: ${{ github.workspace }}
       working-directory: python
       run: tox -e lint,mypy,doc,py3
+
+    - name: install pypy
+      if: ${{ matrix.python }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: 'pypy${{ matrix.python }}'
+
+    - name: run pypy tests
+      if: ${{ matrix.python }}
+      env:
+        DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
+        DCC_RS_TARGET: debug
+        DCC_RS_DEV: ${{ github.workspace }}
+      working-directory: python
+      run: tox -e pypy3

.github/workflows/jsonrpc_api.yml

@@ -1,66 +0,0 @@
-name: JSON-RPC API Test
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: 1.56.0
-          override: true
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v1.3.0
-      - name: Build
-        run: cargo build --verbose --features webserver -p deltachat-jsonrpc
-      - name: Run tests
-        run: cargo test --verbose --features webserver -p deltachat-jsonrpc
-
-  ts_bindings:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js 16.x
-        uses: actions/setup-node@v1
-        with:
-          node-version: 16.x
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: 1.56.0
-          override: true
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v1.3.0
-      - name: npm i
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm i
-      - name: npm run generate-bindings
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm run generate-bindings
-      - name: npm run check ts
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npx tsc --noEmit
-      - name: run integration tests
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm run build
-          cargo build --features webserver
-          npm run test:integration
-      - name: run prettier
-        run: |
-          cd deltachat-jsonrpc/typescript
-          npm run prettier:check

.npmignore

@@ -40,17 +40,3 @@ node/old_docs.md
 .vscode/
 .github/
 node/.prettierrc.yml
-
-deltachat-jsonrpc/TODO.md
-deltachat-jsonrpc/README.MD
-deltachat-jsonrpc/.gitignore
-deltachat-jsonrpc/typescript/.gitignore
-deltachat-jsonrpc/typescript/.prettierignore
-deltachat-jsonrpc/typescript/accounts/
-deltachat-jsonrpc/typescript/index.html
-deltachat-jsonrpc/typescript/node-demo.js
-deltachat-jsonrpc/typescript/report_api_coverage.mjs
-deltachat-jsonrpc/typescript/test
-deltachat-jsonrpc/typescript/example.ts
-
-.DS_Store

CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## Unreleased
 
+### Changes
+
+### Fixes
+
+
+## 1.88.0
+
+### Changes
+- Implemented "Automatic e-mail address Porting" (AEAP). You can
+  configure a new address in DC now, and when receivers get messages
+  they will automatically recognize your moving to a new address. #3385
+- switch from `async-std` to `tokio` as the async runtime #3449
+- upgrade to `pgp@0.8.0` #3467
+- add IMAP ID extension support #3468
+- configure DeltaChat folder by selecting it, so it is configured even if not LISTed #3371
+- build PyPy wheels #6683
+- improve default error if NDN does not provide an error #3456
+- increase ratelimit from 3 to 6 messages per 60 seconds #3481
+
+### Fixes
+- mailing list: remove square-brackets only for first name #3452
+- do not use footers from mailinglists as the contact status #3460
+- don't ignore KML parsing errors #3473
+
+
+## 1.87.0
+
 ### Changes
 - limit the rate of MDN sending #3402
 - ignore ratelimits for bots #3439
@@ -9,9 +36,10 @@
 - format message lines starting with `>` as quotes #3434
 - node: remove `split2` dependency #3418
 - node: add git installation info to readme #3418
+- limit the rate of webxdc update sending #3417
 
 ### Fixes
-- set a default error if NDN does not provide an error
+- set a default error if NDN does not provide an error #3410
 - python: avoid exceptions when messages/contacts/chats are compared with `None`
 - node: wait for the event loop to stop before destroying contexts #3431 #3451
 - emit configuration errors via event on failure #3433
@@ -24,6 +52,7 @@
 - python: added `Message.is_videochat_invitation()`  #3416
 - python: added support for "videochat" and "webxdc" view types to `Message.new_empty()`  #3416
 
+
 ## 1.86.0
 
 ### API-Changes

CMakeLists.txt

@@ -21,7 +21,7 @@ add_custom_command(
         PREFIX=${CMAKE_INSTALL_PREFIX}
         LIBDIR=${CMAKE_INSTALL_FULL_LIBDIR}
         INCLUDEDIR=${CMAKE_INSTALL_FULL_INCLUDEDIR}
-        ${CARGO} build --release --no-default-features --features jsonrpc
+        ${CARGO} build --release --no-default-features
 
 	# Build in `deltachat-ffi` directory instead of using
 	# `--package deltachat_ffi` to avoid feature resolver version

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.86.0"
+version = "1.88.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2021"
 license = "MPL-2.0"
@@ -9,6 +9,7 @@ rust-version = "1.56"
 [profile.dev]
 debug = 0
 panic = 'abort'
+opt-level = 1
 
 [profile.release]
 lto = true
@@ -19,19 +20,19 @@ deltachat_derive = { path = "./deltachat_derive" }
 
 ansi_term = { version = "0.12.1", optional = true }
 anyhow = "1"
-async-imap = { git = "https://github.com/async-email/async-imap" }
-async-native-tls = { version = "0.3" }
-async-smtp = { git = "https://github.com/async-email/async-smtp", branch="master", default-features=false, features = ["smtp-transport", "socks5"] }
-async-std-resolver = "0.21"
-async-std = { version = "1" }
-async-tar = { version = "0.4", default-features=false }
+async-imap = { git = "https://github.com/async-email/async-imap", branch = "master", default-features = false, features = ["runtime-tokio"] }
+async-native-tls = { version = "0.4", default-features = false, features = ["runtime-tokio"] }
+async-smtp = { version = "0.5", default-features = false, features = ["smtp-transport", "socks5", "runtime-tokio"] }
+trust-dns-resolver = "0.21"
+tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
+tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar
 backtrace = "0.3"
 base64 = "0.13"
 bitflags = "1.3"
 chrono = { version = "0.4", default-features=false, features = ["clock", "std"] }
 dirs = { version = "4", optional=true }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
-encoded-words = { git = "https://github.com/async-email/encoded-words", branch="master" }
+encoded-words = "0.2"
 escaper = "0.1"
 futures = "0.3"
 hex = "0.4.0"
@@ -47,12 +48,12 @@ num-derive = "0.3"
 num-traits = "0.2"
 once_cell = "1.12.0"
 percent-encoding = "2.0"
-pgp = { version = "0.7", default-features = false }
+pgp = { version = "0.8", default-features = false }
 pretty_env_logger = { version = "0.4", optional = true }
 quick-xml = "0.23"
 r2d2 = "0.8"
 r2d2_sqlite = "0.20"
-rand = "0.7"
+rand = "0.8"
 regex = "1.5"
 rusqlite = { version = "0.27", features = ["sqlcipher"] }
 rust-hsluv = "0.1"
@@ -65,33 +66,35 @@ sha2 = "0.10"
 smallvec = "1"
 strum = "0.24"
 strum_macros = "0.24"
-surf = { version = "2.3", default-features = false, features = ["h1-client"] }
 thiserror = "1"
 toml = "0.5"
 url = "2"
 uuid = { version = "1", features = ["serde", "v4"] }
-fast-socks5 = "0.4"
+fast-socks5 = "0.8"
 humansize = "1"
 qrcodegen = "1.7.0"
 tagger = "4.3.3"
 textwrap = "0.15.0"
-zip = { version = "0.6.2", default-features = false, features = ["deflate"] }
+async-channel = "1.6.1"
+futures-lite = "1.12.0"
+tokio-stream = { version = "0.1.9", features = ["fs"] }
+reqwest = { version = "0.11.11", features = ["json"] }
+async_zip = { git = "https://github.com/dignifiedquire/rs-async-zip", branch = "main", default-features = false, features = ["deflate"] }
 
 [dev-dependencies]
 ansi_term = "0.12.0"
-async-std = { version = "1", features = ["unstable", "attributes"] }
-criterion = { version = "0.3.4", features = ["async_std"] }
+criterion = { version = "0.3.4", features = ["async_tokio"] }
 futures-lite = "1.12"
 log = "0.4"
 pretty_env_logger = "0.4"
 proptest = { version = "1", default-features = false, features = ["std"] }
 tempfile = "3"
+tokio = { version = "1", features = ["parking_lot", "rt-multi-thread", "macros"] }
 
 [workspace]
 members = [
   "deltachat-ffi",
   "deltachat_derive",
-  "deltachat-jsonrpc"
 ]
 
 [[example]]
@@ -133,5 +136,10 @@ harness = false
 default = ["vendored"]
 internals = []
 repl = ["internals", "rustyline", "log", "pretty_env_logger", "ansi_term", "dirs"]
-vendored = ["async-native-tls/vendored", "async-smtp/native-tls-vendored", "rusqlite/bundled-sqlcipher-vendored-openssl"]
+vendored = [
+  "async-native-tls/vendored",
+  "async-smtp/native-tls-vendored",
+  "rusqlite/bundled-sqlcipher-vendored-openssl",
+  "reqwest/native-tls-vendored"
+]
 nightly = ["pgp/nightly"]

benches/contacts.rs

@@ -1,4 +1,3 @@
-use async_std::task::block_on;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::contact::Contact;
 use deltachat::context::Context;
@@ -9,9 +8,7 @@ async fn address_book_benchmark(n: u32, read_count: u32) {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
     let id = 100;
-    let context = Context::new(dbfile.into(), id, Events::new())
-        .await
-        .unwrap();
+    let context = Context::new(&dbfile, id, Events::new()).await.unwrap();
 
     let book = (0..n)
         .map(|i| format!("Name {}\naddr{}@example.org\n", i, i))
@@ -27,12 +24,16 @@ async fn address_book_benchmark(n: u32, read_count: u32) {
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
+    let rt = tokio::runtime::Runtime::new().unwrap();
+
     c.bench_function("create 500 contacts", |b| {
-        b.iter(|| block_on(async { address_book_benchmark(black_box(500), black_box(0)).await }))
+        b.to_async(&rt)
+            .iter(|| async { address_book_benchmark(black_box(500), black_box(0)).await })
     });
 
     c.bench_function("create 100 contacts and read it 1000 times", |b| {
-        b.iter(|| block_on(async { address_book_benchmark(black_box(100), black_box(1000)).await }))
+        b.to_async(&rt)
+            .iter(|| async { address_book_benchmark(black_box(100), black_box(1000)).await })
     });
 }
 

benches/create_account.rs

@@ -1,12 +1,11 @@
-use async_std::path::PathBuf;
-use async_std::task::block_on;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::accounts::Accounts;
+use std::path::PathBuf;
 use tempfile::tempdir;
 
 async fn create_accounts(n: u32) {
     let dir = tempdir().unwrap();
-    let p: PathBuf = dir.path().join("accounts").into();
+    let p: PathBuf = dir.path().join("accounts");
 
     let mut accounts = Accounts::new(p.clone()).await.unwrap();
 
@@ -18,7 +17,8 @@ async fn create_accounts(n: u32) {
 
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("create 1 account", |b| {
-        b.iter(|| block_on(async { create_accounts(black_box(1)).await }))
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        b.to_async(&rt).iter(|| create_accounts(black_box(1)))
     });
 }
 

benches/get_chat_msgs.rs

@@ -1,6 +1,5 @@
-use async_std::path::Path;
+use std::path::Path;
 
-use criterion::async_executor::AsyncStdExecutor;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 use deltachat::chat::{self, ChatId};
@@ -10,9 +9,7 @@ use deltachat::Events;
 
 async fn get_chat_msgs_benchmark(dbfile: &Path, chats: &[ChatId]) {
     let id = 100;
-    let context = Context::new(dbfile.into(), id, Events::new())
-        .await
-        .unwrap();
+    let context = Context::new(dbfile, id, Events::new()).await.unwrap();
 
     for c in chats.iter().take(10) {
         black_box(chat::get_chat_msgs(&context, *c, 0).await.ok());
@@ -23,8 +20,10 @@ fn criterion_benchmark(c: &mut Criterion) {
     // To enable this benchmark, set `DELTACHAT_BENCHMARK_DATABASE` to some large database with many
     // messages, such as your primary account.
     if let Ok(path) = std::env::var("DELTACHAT_BENCHMARK_DATABASE") {
-        let chats: Vec<_> = async_std::task::block_on(async {
-            let context = Context::new((&path).into(), 100, Events::new())
+        let rt = tokio::runtime::Runtime::new().unwrap();
+
+        let chats: Vec<_> = rt.block_on(async {
+            let context = Context::new(Path::new(&path), 100, Events::new())
                 .await
                 .unwrap();
             let chatlist = Chatlist::try_load(&context, 0, None, None).await.unwrap();
@@ -33,7 +32,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         });
 
         c.bench_function("chat::get_chat_msgs (load messages from 10 chats)", |b| {
-            b.to_async(AsyncStdExecutor)
+            b.to_async(&rt)
                 .iter(|| get_chat_msgs_benchmark(black_box(path.as_ref()), black_box(&chats)))
         });
     } else {

benches/get_chatlist.rs

@@ -1,4 +1,5 @@
-use criterion::async_executor::AsyncStdExecutor;
+use std::path::Path;
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 use deltachat::chatlist::Chatlist;
@@ -13,11 +14,14 @@ fn criterion_benchmark(c: &mut Criterion) {
     // To enable this benchmark, set `DELTACHAT_BENCHMARK_DATABASE` to some large database with many
     // messages, such as your primary account.
     if let Ok(path) = std::env::var("DELTACHAT_BENCHMARK_DATABASE") {
-        let context = async_std::task::block_on(async {
-            Context::new(path.into(), 100, Events::new()).await.unwrap()
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let context = rt.block_on(async {
+            Context::new(Path::new(&path), 100, Events::new())
+                .await
+                .unwrap()
         });
         c.bench_function("chatlist:try_load (Get Chatlist)", |b| {
-            b.to_async(AsyncStdExecutor)
+            b.to_async(&rt)
                 .iter(|| get_chat_list_benchmark(black_box(&context)))
         });
     } else {

benches/receive_emails.rs

@@ -1,13 +1,11 @@
-use async_std::{path::PathBuf, task::block_on};
-use criterion::{
-    async_executor::AsyncStdExecutor, black_box, criterion_group, criterion_main, BatchSize,
-    Criterion,
-};
+use std::path::PathBuf;
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::{
     config::Config,
     context::Context,
-    dc_receive_imf::dc_receive_imf,
     imex::{imex, ImexMode},
+    receive_imf::receive_imf,
     Events,
 };
 use tempfile::tempdir;
@@ -32,7 +30,7 @@ Hello {i}",
             i = i,
             i_dec = i - 1,
         );
-        dc_receive_imf(&context, black_box(imf_raw.as_bytes()), false)
+        receive_imf(&context, black_box(imf_raw.as_bytes()), false)
             .await
             .unwrap();
     }
@@ -43,15 +41,13 @@ async fn create_context() -> Context {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
     let id = 100;
-    let context = Context::new(dbfile.into(), id, Events::new())
-        .await
-        .unwrap();
+    let context = Context::new(&dbfile, id, Events::new()).await.unwrap();
 
     let backup: PathBuf = std::env::current_dir()
         .unwrap()
-        .join("delta-chat-backup.tar")
-        .into();
-    if backup.exists().await {
+        .join("delta-chat-backup.tar");
+
+    if backup.exists() {
         println!("Importing backup");
         imex(&context, ImexMode::ImportBackup, &backup, None)
             .await
@@ -74,11 +70,15 @@ async fn create_context() -> Context {
 fn criterion_benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("Receive messages");
     group.bench_function("Receive 100 simple text msgs", |b| {
-        b.to_async(AsyncStdExecutor).iter_batched(
-            || block_on(create_context()),
-            |context| recv_all_emails(black_box(context)),
-            BatchSize::LargeInput,
-        );
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let context = rt.block_on(create_context());
+
+        b.to_async(&rt).iter(|| {
+            let ctx = context.clone();
+            async move {
+                recv_all_emails(black_box(ctx)).await;
+            }
+        });
     });
     group.finish();
 }

benches/search_msgs.rs

@@ -1,13 +1,11 @@
-use async_std::task::block_on;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::context::Context;
 use deltachat::Events;
 use std::path::Path;
 
-async fn search_benchmark(path: impl AsRef<Path>) {
-    let dbfile = path.as_ref();
+async fn search_benchmark(dbfile: impl AsRef<Path>) {
     let id = 100;
-    let context = Context::new(dbfile.into(), id, Events::new())
+    let context = Context::new(dbfile.as_ref(), id, Events::new())
         .await
         .unwrap();
 
@@ -20,8 +18,10 @@ fn criterion_benchmark(c: &mut Criterion) {
     // To enable this benchmark, set `DELTACHAT_BENCHMARK_DATABASE` to some large database with many
     // messages, such as your primary account.
     if let Ok(path) = std::env::var("DELTACHAT_BENCHMARK_DATABASE") {
+        let rt = tokio::runtime::Runtime::new().unwrap();
+
         c.bench_function("search hello", |b| {
-            b.iter(|| block_on(async { search_benchmark(black_box(&path)).await }))
+            b.to_async(&rt).iter(|| search_benchmark(black_box(&path)))
         });
     } else {
         println!("env var not set: DELTACHAT_BENCHMARK_DATABASE");

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.86.0"
+version = "1.88.0"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
@@ -16,19 +16,18 @@ crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
 deltachat = { path = "../", default-features = false }
-deltachat-jsonrpc = { path = "../deltachat-jsonrpc", optional = true }
 libc = "0.2"
 human-panic = "1"
 num-traits = "0.2"
 serde_json = "1.0"
-async-std = "1"
+tokio = { version = "1", features = ["rt-multi-thread"] }
 anyhow = "1"
 thiserror = "1"
 rand = "0.7"
+once_cell = "1.12.0"
 
 [features]
 default = ["vendored"]
 vendored = ["deltachat/vendored"]
 nightly = ["deltachat/nightly"]
-jsonrpc = ["deltachat-jsonrpc"]
 

deltachat-ffi/build.rs

@@ -1,4 +1,3 @@
-use std::io::Write;
 use std::path::PathBuf;
 use std::{env, fs};
 
@@ -28,8 +27,9 @@ fn main() {
     );
 
     fs::create_dir_all(target_path.join("pkgconfig")).unwrap();
-    fs::File::create(target_path.join("pkgconfig").join("deltachat.pc"))
-        .unwrap()
-        .write_all(pkg_config.as_bytes())
-        .unwrap();
+    fs::write(
+        target_path.join("pkgconfig").join("deltachat.pc"),
+        pkg_config.as_bytes(),
+    )
+    .unwrap();
 }

deltachat-ffi/deltachat.h

@@ -23,7 +23,7 @@ typedef struct _dc_provider dc_provider_t;
 typedef struct _dc_event    dc_event_t;
 typedef struct _dc_event_emitter dc_event_emitter_t;
 typedef struct _dc_accounts_event_emitter dc_accounts_event_emitter_t;
-typedef struct _dc_jsonrpc_instance dc_jsonrpc_instance_t;
+
 
 /**
  * @mainpage Getting started
@@ -5178,55 +5178,6 @@ int64_t          dc_lot_get_timestamp     (const dc_lot_t* lot);
  */
 
 
-
-/**
- * @class dc_jsonrpc_instance_t
- *
- * Opaque object for using the json rpc api from the cffi bindings.
- */
-
-/**
- * Create the jsonrpc instance that is used to call the jsonrpc.
- *
- * @memberof dc_accounts_t
- * @param account_manager The accounts object as created by dc_accounts_new().
- * @return Returns the jsonrpc instance, NULL on errors.
- *     Must be freed using dc_jsonrpc_unref() after usage.
- *
- */
-dc_jsonrpc_instance_t* dc_jsonrpc_init(dc_accounts_t* account_manager);
-
-/**
- * Free a jsonrpc instance.
- *
- * @memberof dc_jsonrpc_instance_t
- * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
- *     If NULL is given, nothing is done and an error is logged.
- */
-void dc_jsonrpc_unref(dc_jsonrpc_instance_t* jsonrpc_instance);
-
-/**
- * Makes an asynchronous jsonrpc request,
- * returns immediately and once the result is ready it can be retrieved via dc_jsonrpc_next_response()
- * the jsonrpc specification defines an invocation id that can then be used to match request and response.
- *
- * @memberof dc_jsonrpc_instance_t
- * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
- * @param request JSON-RPC request as string
- */
-void dc_jsonrpc_request(dc_jsonrpc_instance_t* jsonrpc_instance, char* request);
-
-/**
- * Get the next json_rpc response, blocks until there is a new event, so call this in a loop from a thread.
- *
- * @memberof dc_jsonrpc_instance_t
- * @param jsonrpc_instance jsonrpc instance as returned from dc_jsonrpc_init().
- * @return JSON-RPC response as string
- *     If NULL is returned, the accounts_t belonging to the jsonrpc instance is unref'd and no more events will come;
- *     in this case, free the jsonrpc instance using dc_jsonrpc_unref().
- */
-char* dc_jsonrpc_next_response(dc_jsonrpc_instance_t* jsonrpc_instance);
-
 /**
  * @class dc_event_emitter_t
  *

deltachat-ffi/src/lib.rs

@@ -1,4 +1,4 @@
-#![deny(unused, clippy::all)]
+#![warn(unused, clippy::all)]
 #![allow(
     non_camel_case_types,
     non_snake_case,
@@ -15,18 +15,19 @@ extern crate human_panic;
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
 use std::fmt::Write;
+use std::future::Future;
 use std::ops::Deref;
 use std::ptr;
 use std::str::FromStr;
-use std::sync::Arc;
 use std::time::{Duration, SystemTime};
 
 use anyhow::Context as _;
-use async_std::sync::RwLock;
-use async_std::task::{block_on, spawn};
 use deltachat::qr_code_generator::get_securejoin_qr_svg;
 use num_traits::{FromPrimitive, ToPrimitive};
+use once_cell::sync::Lazy;
 use rand::Rng;
+use tokio::runtime::Runtime;
+use tokio::sync::RwLock;
 
 use deltachat::chat::{ChatId, ChatVisibility, MuteDuration, ProtectionStatus};
 use deltachat::constants::DC_MSG_ID_LAST_SPECIAL;
@@ -39,6 +40,7 @@ use deltachat::stock_str::StockMessage;
 use deltachat::webxdc::StatusUpdateSerial;
 use deltachat::*;
 use deltachat::{accounts::Accounts, log::LogExt};
+use tokio::task::JoinHandle;
 
 mod dc_array;
 mod lot;
@@ -62,6 +64,23 @@ use deltachat::chatlist::Chatlist;
 /// Struct representing the deltachat context.
 pub type dc_context_t = Context;
 
+static RT: Lazy<Runtime> = Lazy::new(|| Runtime::new().expect("unable to create tokio runtime"));
+
+fn block_on<T>(fut: T) -> T::Output
+where
+    T: Future,
+{
+    RT.block_on(fut)
+}
+
+fn spawn<T>(fut: T) -> JoinHandle<T::Output>
+where
+    T: Future + Send + 'static,
+    T::Output: Send + 'static,
+{
+    RT.spawn(fut)
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_context_new(
     _os_name: *const libc::c_char,
@@ -78,11 +97,7 @@ pub unsafe extern "C" fn dc_context_new(
     let ctx = if blobdir.is_null() || *blobdir == 0 {
         // generate random ID as this functionality is not yet available on the C-api.
         let id = rand::thread_rng().gen();
-        block_on(Context::new(
-            as_path(dbfile).to_path_buf().into(),
-            id,
-            Events::new(),
-        ))
+        block_on(Context::new(as_path(dbfile), id, Events::new()))
     } else {
         eprintln!("blobdir can not be defined explicitly anymore");
         return ptr::null_mut();
@@ -106,11 +121,7 @@ pub unsafe extern "C" fn dc_context_new_closed(dbfile: *const libc::c_char) -> *
     }
 
     let id = rand::thread_rng().gen();
-    match block_on(Context::new_closed(
-        as_path(dbfile).to_path_buf().into(),
-        id,
-        Events::new(),
-    )) {
+    match block_on(Context::new_closed(as_path(dbfile), id, Events::new())) {
         Ok(context) => Box::into_raw(Box::new(context)),
         Err(err) => {
             eprintln!("failed to create context: {:#}", err);
@@ -384,7 +395,7 @@ pub unsafe extern "C" fn dc_get_oauth2_url(
     let redirect = to_string_lossy(redirect);
 
     block_on(async move {
-        match oauth2::dc_get_oauth2_url(ctx, &addr, &redirect)
+        match oauth2::get_oauth2_url(ctx, &addr, &redirect)
             .await
             .log_err(ctx, "dc_get_oauth2_url failed")
         {
@@ -682,10 +693,13 @@ pub unsafe extern "C" fn dc_get_next_event(events: *mut dc_event_emitter_t) -> *
     }
     let events = &*events;
 
-    events
-        .recv_sync()
-        .map(|ev| Box::into_raw(Box::new(ev)))
-        .unwrap_or_else(ptr::null_mut)
+    block_on(async move {
+        events
+            .recv()
+            .await
+            .map(|ev| Box::into_raw(Box::new(ev)))
+            .unwrap_or_else(ptr::null_mut)
+    })
 }
 
 #[no_mangle]
@@ -725,7 +739,7 @@ pub unsafe extern "C" fn dc_preconfigure_keypair(
     }
     let ctx = &*context;
     block_on(async move {
-        let addr = dc_tools::EmailAddress::new(&to_string_lossy(addr))?;
+        let addr = tools::EmailAddress::new(&to_string_lossy(addr))?;
         let public = key::SignedPublicKey::from_asc(&to_string_lossy(public_data))?.0;
         let secret = key::SignedSecretKey::from_asc(&to_string_lossy(secret_data))?.0;
         let keypair = key::KeyPair {
@@ -2230,7 +2244,7 @@ pub unsafe extern "C" fn dc_get_securejoin_qr(
         Some(ChatId::new(chat_id))
     };
 
-    block_on(securejoin::dc_get_securejoin_qr(ctx, chat_id))
+    block_on(securejoin::get_securejoin_qr(ctx, chat_id))
         .unwrap_or_else(|_| "".to_string())
         .strdup()
 }
@@ -2268,7 +2282,7 @@ pub unsafe extern "C" fn dc_join_securejoin(
     let ctx = &*context;
 
     block_on(async move {
-        securejoin::dc_join_securejoin(ctx, &to_string_lossy(qr))
+        securejoin::join_securejoin(ctx, &to_string_lossy(qr))
             .await
             .map(|chatid| chatid.to_u32())
             .log_err(ctx, "failed dc_join_securejoin() call")
@@ -2394,7 +2408,7 @@ pub unsafe extern "C" fn dc_get_last_error(context: *mut dc_context_t) -> *mut l
         return "".strdup();
     }
     let ctx = &*context;
-    block_on(ctx.get_last_error()).strdup()
+    ctx.get_last_error().strdup()
 }
 
 // dc_array_t
@@ -4094,11 +4108,11 @@ pub unsafe extern "C" fn dc_provider_unref(provider: *mut dc_provider_t) {
 /// Reader-writer lock wrapper for accounts manager to guarantee thread safety when using
 /// `dc_accounts_t` in multiple threads at once.
 pub struct AccountsWrapper {
-    inner: Arc<RwLock<Accounts>>,
+    inner: RwLock<Accounts>,
 }
 
 impl Deref for AccountsWrapper {
-    type Target = Arc<RwLock<Accounts>>;
+    type Target = RwLock<Accounts>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
@@ -4107,7 +4121,7 @@ impl Deref for AccountsWrapper {
 
 impl AccountsWrapper {
     fn new(accounts: Accounts) -> Self {
-        let inner = Arc::new(RwLock::new(accounts));
+        let inner = RwLock::new(accounts);
         Self { inner }
     }
 }
@@ -4127,7 +4141,7 @@ pub unsafe extern "C" fn dc_accounts_new(
         return ptr::null_mut();
     }
 
-    let accs = block_on(Accounts::new(as_path(dbfile).to_path_buf().into()));
+    let accs = block_on(Accounts::new(as_path(dbfile).into()));
 
     match accs {
         Ok(accs) => Box::into_raw(Box::new(AccountsWrapper::new(accs))),
@@ -4299,7 +4313,7 @@ pub unsafe extern "C" fn dc_accounts_migrate_account(
     block_on(async move {
         let mut accounts = accounts.write().await;
         match accounts
-            .migrate_account(async_std::path::PathBuf::from(dbfile))
+            .migrate_account(std::path::PathBuf::from(dbfile))
             .await
         {
             Ok(id) => id,
@@ -4419,83 +4433,7 @@ pub unsafe extern "C" fn dc_accounts_get_next_event(
         return ptr::null_mut();
     }
     let emitter = &mut *emitter;
-
-    emitter
-        .recv_sync()
+    block_on(emitter.recv())
         .map(|ev| Box::into_raw(Box::new(ev)))
         .unwrap_or_else(ptr::null_mut)
 }
-
-#[cfg(feature = "jsonrpc")]
-mod jsonrpc {
-    use super::*;
-    use deltachat_jsonrpc::api::CommandApi;
-    use deltachat_jsonrpc::yerpc::{MessageHandle, RpcHandle};
-
-    pub struct dc_jsonrpc_instance_t {
-        receiver: async_std::channel::Receiver<deltachat_jsonrpc::yerpc::Message>,
-        handle: MessageHandle<CommandApi>,
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn dc_jsonrpc_init(
-        account_manager: *mut dc_accounts_t,
-    ) -> *mut dc_jsonrpc_instance_t {
-        if account_manager.is_null() {
-            eprintln!("ignoring careless call to dc_jsonrpc_init()");
-            return ptr::null_mut();
-        }
-
-        let cmd_api =
-            deltachat_jsonrpc::api::CommandApi::new_from_arc((*account_manager).inner.clone());
-
-        let (request_handle, receiver) = RpcHandle::new();
-        let handle = MessageHandle::new(request_handle, cmd_api);
-
-        let instance = dc_jsonrpc_instance_t { receiver, handle };
-
-        Box::into_raw(Box::new(instance))
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn dc_jsonrpc_unref(jsonrpc_instance: *mut dc_jsonrpc_instance_t) {
-        if jsonrpc_instance.is_null() {
-            eprintln!("ignoring careless call to dc_jsonrpc_unref()");
-            return;
-        }
-
-        Box::from_raw(jsonrpc_instance);
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn dc_jsonrpc_request(
-        jsonrpc_instance: *mut dc_jsonrpc_instance_t,
-        request: *const libc::c_char,
-    ) {
-        if jsonrpc_instance.is_null() || request.is_null() {
-            eprintln!("ignoring careless call to dc_jsonrpc_request()");
-            return;
-        }
-
-        let api = &*jsonrpc_instance;
-        let handle = &api.handle;
-        let request = to_string_lossy(request);
-        async_std::task::spawn(async move {
-            handle.handle_message(&request).await;
-        });
-    }
-
-    #[no_mangle]
-    pub unsafe extern "C" fn dc_jsonrpc_next_response(
-        jsonrpc_instance: *mut dc_jsonrpc_instance_t,
-    ) -> *mut libc::c_char {
-        if jsonrpc_instance.is_null() {
-            eprintln!("ignoring careless call to dc_jsonrpc_next_response()");
-            return ptr::null_mut();
-        }
-        let api = &*jsonrpc_instance;
-        async_std::task::block_on(api.receiver.recv())
-            .map(|result| serde_json::to_string(&result).unwrap_or_default().strdup())
-            .unwrap_or(ptr::null_mut())
-    }
-}

deltachat-ffi/src/string.rs

@@ -55,7 +55,7 @@ pub(crate) enum CStringError {
 /// # Example
 ///
 /// ```
-/// use deltachat::dc_tools::{dc_strdup, OsStrExt};
+/// use deltachat::tools::{dc_strdup, OsStrExt};
 /// let path = std::path::Path::new("/some/path");
 /// let path_c = path.to_c_string().unwrap();
 /// unsafe {

deltachat-jsonrpc/.gitignore

@@ -1,3 +0,0 @@
-accounts/
-
-.cargo

deltachat-jsonrpc/Cargo.toml

@@ -1,39 +0,0 @@
-[package]
-name = "deltachat-jsonrpc"
-version = "1.86.0"
-authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
-edition = "2021"
-default-run = "webserver"
-license = "MPL-2.0"
-
-[[bin]]
-name = "webserver"
-path = "src/webserver.rs"
-required-features = ["webserver"]
-
-[dependencies]
-anyhow = "1"
-async-std = { version = "1", features = ["attributes"] }
-deltachat = { path = ".." }
-num-traits = "0.2"
-serde = { version = "1.0", features = ["derive"] }
-tempfile = "3.3.0"
-log = "0.4"
-async-channel = { version = "1.6.1" }
-futures = { version = "0.3.19" }
-serde_json = "1.0.75"
-yerpc = { git = "https://github.com/Frando/yerpc", features = ["anyhow"] }
-typescript-type-def = { git = "https://github.com/Frando/rust-typescript-type-def", branch = "yerpc", features = ["json_value"] }
-# optional, depended on features
-env_logger = { version = "0.9.0", optional = true }
-tide = { version = "0.16.0", optional = true }
-tide-websockets = { version = "0.4.0", optional = true }
-yerpc-tide = { git = "https://github.com/Frando/yerpc", optional = true }
-
-
-[features]
-default = []
-webserver = ["env_logger", "tide", "tide-websockets", "yerpc-tide"]
-
-[profile.release]
-lto = true

deltachat-jsonrpc/README.MD

@@ -1,75 +0,0 @@
-# deltachat-jsonrpc
-
-## Build Requirements
-
-- Linux or Mac, scrips make use of features like `>` pipes and `&&` (maybe the newer versions of powershell support them, but I didn't try that.)
-- rust (installed via rustup)
-
-## Start the webserver
-
-The webserver is an example usage. Goal of it is to be usable both as example and as base for deltachat-kaiOS.
-
-```sh
-RUST_LOG=info cargo run --features webserver
-```
-
-## Generate Typescript Bindings
-
-```sh
-cd typescript
-npm i
-npm run build
-```
-
-## Run the development example
-
-Mac
-
-```sh
-alias firefox=/Applications/Firefox.app/Contents/MacOS/firefox
-npm run example:build && firefox --devtools $(pwd)/example/browser-example.html
-```
-
-Linux:
-
-```sh
-npm run example:run
-```
-
-## Compiling server for kaiOS or android:
-
-```sh
-cross build --features=webserver --target armv7-linux-androideabi --release
-```
-
-## Run the tests
-
-### Rust tests
-
-```
-cargo test --features=webserver
-```
-
-### Typescript
-
-```
-cd typescript
-npm run test
-```
-
-For the online tests to run you need a test account token for a mailadm instance,
-you can use docker to spin up a local instance: https://github.com/deltachat/docker-mailadm
-
-> set the env var `DCC_NEW_TMP_EMAIL` to your mailadm token: example:
-> `DCC_NEW_TMP_EMAIL=https://testrun.org/new_email?t=1h_195dksa6544`
-
-If your test fail with server shutdown at the start, then you might have a process from a last run still running probably and you need to kill that process manually to continue.
-
-#### Test Coverage
-
-You can test coverage with `npm run coverage`, but you need to have `DCC_NEW_TMP_EMAIL` set, otherwise the result will be useless because some functions can only be tested with the online tests.
-
-> If you are offline and want to see the coverage results anyway (even though they are NOT correct), you can bypass the error with `COVERAGE_OFFLINE=1 npm run coverage`
-
-Open `coverage/index.html` for a detailed report.
-`bindings.ts` is probably the most interesting file for coverage, because it describes the api functions.

deltachat-jsonrpc/TODO.md

@@ -1,347 +0,0 @@
-## Core system
-
-- [X] Base structure of JSON API code 
-- [X] Implement the first methods for testing + the code that should later be generated by the proc macro
-- [X] Create the proc macro
-  - [X] json api
-  - [X] ts types
-    - [X] arguments (no args, one argument, multiple args)
-    - [X] return type
-    - [X] custom types as type aliases that ts file looks prettier
-
-
-## Pre - MVP
-
-- [X] Web socket server
-- [WIP] Web socket client (ts)
-  - [X] backend connection state changed events
-  - [X] Reconnect on connection loss / connection state
-  - [ ] find a way to type the event emitter callback functions
-- [X] Events
-
-## MVP
-
-- [X] mocha integration test for ts api
- - [X] basic tests
- - [X] advanced / "online tests" (mailadm for burner accounts)
-- [ ] coverage for a majority of the API
-- [ ] Blobs served
-- [ ] Blob upload (for attachments, setting profile-picture, importing backup and so on)
-- [ ] Web push API? At least some kind of notification hook closure this lib can accept.
-
-## Other Ideas
-
-- [ ] make sure there can only be one connection at a time to the ws 
-  - why? , it could give problems if its commanded from multiple connections
-- [ ] encrypted connection?
-- [ ] authenticated connection?
-- [ ] Look into unit-testing for the proc macros?
-- [ ] proc macro taking over doc comments to generated typescript file
-- [X] GH action for tests (rust and typescript)
-  - [X] rust test
-  - [X] rust fmt
-  - [X] rust clippy
-  - [X] tsc check
-  - [X] prettier
-  - [X] mocha
-- [X] scripts to check&fix prettier formatting
-
-
-
-## Apis
-
-replicate desktop api feature set:
-
-(this feature set is based on desktop version `1.20`, needs to be updated in the future)
-
-```rs
-
-
-struct sendMessageParams {
-  text: Option<String>,
-  filename: Option<String>, // TODO we need to think about blobs some more
-  location: Option<(u32,u32)>,
-  quote_message_id: Option<u32>,
-}
-
-struct QrCodeResponse = {
-  state: u32 // also enum in reality, for simlicity u32 here
-  id: u32
-  text1: String
-}
-
-impl Api {
-
-// root ---------------------------------------------------------------
-
-// NEEDS_THE_BLOB_QUESTION_ANSWERED_EVENTUALLY
-async fn sc_set_profile_picture(&self, new_image: String) -> Result<()> {}
-
-// NEEDS_THE_BLOB_QUESTION_ANSWERED_EVENTUALLY
-// 'getProfilePicture' equals to `dc.getContact(C.DC_CONTACT_ID_SELF).getProfileImage()` or `dc.get_config("selfavatar")`
-
-async fn sc_join_secure_join(&self, qrCode: String) -> Result<u32> {}
-async fn sc_stop_ongoing_process(&self) -> Result<u32> {}
-async fn sc_check_qr_code(&self, qrCode: String) -> Result<QrCodeResponse> {}
-
-// login ----------------------------------------------------
-
-// INFO: login functions need to call stop&start io where applicable
-
-// login.newLogin:
-// do instead in frontend:
-//   1. call `add_account`
-//   2. call `select_account`
-//   3. set credentials via set config
-//   4. call `sc_configure`
-
-// login.getLogins - is already implemented: `get_all_accounts`
-
-// login.loadAccount - Basically `select_account`
-
-// login.logout -> TODO: unselect account, which isn't implemented in the core yet
-
-// login.forgetAccount -> `remove_account`
-
-// login.getLastLoggedInAccount -> `get_selected_account_id`
-
-// login.updateCredentials -> do instead: set config then call `sc_configure`
-
-// backup -------------------------------------------------------------
-
-// INFO: backup functions need to call stop&start io
-
-// NEEDS_THE_BLOB_QUESTION_ANSWERED_EVENTUALLY
-async fn sc_backup_export(&self, out_dir: String) -> Result<()> {}
-// NEEDS_THE_BLOB_QUESTION_ANSWERED_EVENTUALLY
-async fn sc_backup_import(&self, file: String) -> Result<()> {} // will not return the same as in desktop because this function imports backup to the current context unlike it was in desktop
-
-// chatList -----------------------------------------------------------
-
-// chatList.selectChat - will be removed from desktop
-// chatList.getSelectedChatId - will be removed from desktop
-// chatList.onChatModified - will be removed from desktop
-
-async fn sc_chatlist_get_general_fresh_message_counter(&self) -> Result<u32> // this method might be used for a favicon badge counter
-
-// contacts ------------------------------------------------------------
-
-async fn sc_contacts_change_nickname(&self, contact_id: u32, new_name: String) -> Result<()>
-
-
-// contacts.getChatIdByContactId - very similar to sc_contacts_create_chat_by_contact_id
-// contacts.getDMChatId -  very similar to sc_contacts_create_chat_by_contact_id
-
-async fn sc_contacts_get_encryption_info(&self, contact_id: u32) -> Result<String>
-
-async fn sc_contacts_lookup_contact_id_by_addr(&self, email: String) -> Result<u32>
-
-
-}
-
-```
-```ts
-
-class DeltaRemote {
-  // chat ---------------------------------------------------------------
-  call(
-    fnName: 'chat.getChatMedia',
-    chatId: number,
-    msgType1: number,
-    msgType2: number
-  ): Promise<MessageType[]>
-  call(fnName: 'chat.getEncryptionInfo', chatId: number): Promise<string>
-  call(fnName: 'chat.getQrCode', chatId?: number): Promise<string>
-  call(fnName: 'chat.leaveGroup', chatId: number): Promise<void>
-  call(fnName: 'chat.setName', chatId: number, name: string): Promise<boolean>
-  call(
-    fnName: 'chat.modifyGroup',
-    chatId: number,
-    name: string,
-    image: string,
-    remove: number[],
-    add: number[]
-  ): Promise<boolean>
-  call(
-    fnName: 'chat.addContactToChat',
-    chatId: number,
-    contactId: number
-  ): Promise<boolean>
-  call(
-    fnName: 'chat.setProfileImage',
-    chatId: number,
-    newImage: string
-  ): Promise<boolean>
-  call(
-    fnName: 'chat.setMuteDuration',
-    chatId: number,
-    duration: MuteDuration
-  ): Promise<boolean>
-  call(
-    fnName: 'chat.createGroupChat',
-    verified: boolean,
-    name: string
-  ): Promise<number>
-  call(fnName: 'chat.delete', chatId: number): Promise<void>
-  call(
-    fnName: 'chat.setVisibility',
-    chatId: number,
-    visibility:
-      | C.DC_CERTCK_AUTO
-      | C.DC_CERTCK_STRICT
-      | C.DC_CHAT_VISIBILITY_PINNED
-  ): Promise<void>
-  call(fnName: 'chat.getChatContacts', chatId: number): Promise<number[]>
-  call(fnName: 'chat.markNoticedChat', chatId: number): Promise<void>
-  call(fnName: 'chat.getChatEphemeralTimer', chatId: number): Promise<number>
-  call(
-    fnName: 'chat.setChatEphemeralTimer',
-    chatId: number,
-    ephemeralTimer: number
-  ): Promise<void>
-  call(fnName: 'chat.sendVideoChatInvitation', chatId: number): Promise<number>
-  call(
-    fnName: 'chat.decideOnContactRequest',
-    messageId: number,
-    decision:
-      | C.DC_DECISION_START_CHAT
-      | C.DC_DECISION_NOT_NOW
-      | C.DC_DECISION_BLOCK
-  ): Promise<number>
-  // locations ----------------------------------------------------------
-  call(
-    fnName: 'locations.setLocation',
-    latitude: number,
-    longitude: number,
-    accuracy: number
-  ): Promise<void>
-  call(
-    fnName: 'locations.getLocations',
-    chatId: number,
-    contactId: number,
-    timestampFrom: number,
-    timestampTo: number
-  ): Promise<JsonLocations>
-
-  // NOTHING HERE that is called directly from the frontend, yet
-  // messageList --------------------------------------------------------
-  call(
-    fnName: 'messageList.sendMessage',
-    chatId: number,
-    params: sendMessageParams
-  ): Promise<[number, MessageType | null]>
-  call(
-    fnName: 'messageList.sendSticker',
-    chatId: number,
-    stickerPath: string
-  ): Promise<void>
-  call(fnName: 'messageList.deleteMessage', id: number): Promise<void>
-  call(fnName: 'messageList.getMessageInfo', msgId: number): Promise<string>
-  call(
-    fnName: 'messageList.getDraft',
-    chatId: number
-  ): Promise<MessageType | null>
-  call(
-    fnName: 'messageList.setDraft',
-    chatId: number,
-    {
-      text,
-      file,
-      quotedMessageId,
-    }: { text?: string; file?: string; quotedMessageId?: number }
-  ): Promise<void>
-  call(
-    fnName: 'messageList.messageIdToJson',
-    id: number
-  ): Promise<{ msg: null } | MessageType>
-  call(
-    fnName: 'messageList.forwardMessage',
-    msgId: number,
-    chatId: number
-  ): Promise<void>
-  call(
-    fnName: 'messageList.searchMessages',
-    query: string,
-    chatId?: number
-  ): Promise<number[]>
-  call(
-    fnName: 'messageList.msgIds2SearchResultItems',
-    msgIds: number[]
-  ): Promise<{ [id: number]: MessageSearchResult }>
-  call(
-    fnName: 'messageList.saveMessageHTML2Disk',
-    messageId: number
-  ): Promise<string>
-  // settings -----------------------------------------------------------
-  call(fnName: 'settings.keysImport', directory: string): Promise<void>
-  call(fnName: 'settings.keysExport', directory: string): Promise<void>
-  call(
-    fnName: 'settings.serverFlags',
-    {
-      mail_security,
-      send_security,
-    }: {
-      mail_security?: string
-      send_security?: string
-    }
-  ): Promise<number | ''>
-  call(
-    fnName: 'settings.setDesktopSetting',
-    key: keyof DesktopSettings,
-    value: string | number | boolean
-  ): Promise<boolean>
-  call(fnName: 'settings.getDesktopSettings'): Promise<DesktopSettings>
-  call(
-    fnName: 'settings.saveBackgroundImage',
-    file: string,
-    isDefaultPicture: boolean
-  ): Promise<string>
-  call(
-    fnName: 'settings.estimateAutodeleteCount',
-    fromServer: boolean,
-    seconds: number
-  ): Promise<number>
-  // stickers -----------------------------------------------------------
-  call(
-    fnName: 'stickers.getStickers'
-  ): Promise<{
-    [key: string]: string[]
-  }> // todo move to extras? because its not directly elated to core
-  // context ------------------------------------------------------------
-  call(fnName: 'context.maybeNetwork'): Promise<void>
-  // burner accounts ------------------------------------------------------------
-  call(
-    fnName: 'burnerAccounts.create',
-    url: string
-  ): Promise<{ email: string; password: string }> // think about how to improve that api - probably use core api instead
-  // extras -------------------------------------------------------------
-  call(fnName: 'extras.getLocaleData', locale: string): Promise<LocaleData>
-  call(fnName: 'extras.setLocale', locale: string): Promise<void>
-  call(
-    fnName: 'extras.getActiveTheme'
-  ): Promise<{
-    theme: Theme
-    data: string
-  } | null>
-  call(fnName: 'extras.setThemeFilePath', address: string): void
-  call(fnName: 'extras.getAvailableThemes'): Promise<Theme[]>
-  call(fnName: 'extras.setTheme', address: string): Promise<boolean>
-  // catchall: ----------------------------------------------------------
-  call(fnName: string): Promise<any>
-  call(fnName: string, ...args: any[]): Promise<any> {
-    return _callDcMethodAsync(fnName, ...args)
-  }
-}
-
-export const DeltaBackend = new DeltaRemote()
-```
-
-
-after that, or while doing it adjust api to be more complete
-
-
-
-
-TODO different test to simulate two devices:
-
-to test autocrypt_initiate_key_transfer & autocrypt_continue_key_transfer

deltachat-jsonrpc/src/api/events.rs

@@ -1,154 +0,0 @@
-use deltachat::{Event, EventType};
-use serde::Serialize;
-use serde_json::{json, Value};
-use typescript_type_def::TypeDef;
-
-pub fn event_to_json_rpc_notification(event: Event) -> Value {
-    let (field1, field2): (Value, Value) = match &event.typ {
-        // events with a single string in field1
-        EventType::Info(txt)
-        | EventType::SmtpConnected(txt)
-        | EventType::ImapConnected(txt)
-        | EventType::SmtpMessageSent(txt)
-        | EventType::ImapMessageDeleted(txt)
-        | EventType::ImapMessageMoved(txt)
-        | EventType::NewBlobFile(txt)
-        | EventType::DeletedBlobFile(txt)
-        | EventType::Warning(txt)
-        | EventType::Error(txt)
-        | EventType::ErrorSelfNotInGroup(txt) => (json!(txt), Value::Null),
-        EventType::ImexFileWritten(path) => (json!(path.to_str()), Value::Null),
-        // single number
-        EventType::MsgsNoticed(chat_id) | EventType::ChatModified(chat_id) => {
-            (json!(chat_id), Value::Null)
-        }
-        EventType::ImexProgress(progress) => (json!(progress), Value::Null),
-        // both fields contain numbers
-        EventType::MsgsChanged { chat_id, msg_id }
-        | EventType::IncomingMsg { chat_id, msg_id }
-        | EventType::MsgDelivered { chat_id, msg_id }
-        | EventType::MsgFailed { chat_id, msg_id }
-        | EventType::MsgRead { chat_id, msg_id } => (json!(chat_id), json!(msg_id)),
-        EventType::ChatEphemeralTimerModified { chat_id, timer } => (json!(chat_id), json!(timer)),
-        EventType::SecurejoinInviterProgress {
-            contact_id,
-            progress,
-        }
-        | EventType::SecurejoinJoinerProgress {
-            contact_id,
-            progress,
-        } => (json!(contact_id), json!(progress)),
-        // field 1 number or null
-        EventType::ContactsChanged(maybe_number) | EventType::LocationChanged(maybe_number) => (
-            match maybe_number {
-                Some(number) => json!(number),
-                None => Value::Null,
-            },
-            Value::Null,
-        ),
-        // number and maybe string
-        EventType::ConfigureProgress { progress, comment } => (
-            json!(progress),
-            match comment {
-                Some(content) => json!(content),
-                None => Value::Null,
-            },
-        ),
-        EventType::ConnectivityChanged => (Value::Null, Value::Null),
-        EventType::SelfavatarChanged => (Value::Null, Value::Null),
-        EventType::WebxdcStatusUpdate {
-            msg_id,
-            status_update_serial,
-        } => (json!(msg_id), json!(status_update_serial)),
-    };
-
-    json!({
-        "id": event_type_to_string(event.typ),
-        "contextId": event.id,
-        "field1": field1,
-        "field2": field2
-    })
-}
-
-#[derive(Serialize, TypeDef)]
-pub enum EventTypeName {
-    Info,
-    SmtpConnected,
-    ImapConnected,
-    SmtpMessageSent,
-    ImapMessageDeleted,
-    ImapMessageMoved,
-    NewBlobFile,
-    DeletedBlobFile,
-    Warning,
-    Error,
-    ErrorSelfNotInGroup,
-    MsgsChanged,
-    IncomingMsg,
-    MsgsNoticed,
-    MsgDelivered,
-    MsgFailed,
-    MsgRead,
-    ChatModified,
-    ChatEphemeralTimerModified,
-    ContactsChanged,
-    LocationChanged,
-    ConfigureProgress,
-    ImexProgress,
-    ImexFileWritten,
-    SecurejoinInviterProgress,
-    SecurejoinJoinerProgress,
-    ConnectivityChanged,
-    SelfavatarChanged,
-    WebxdcStatusUpdate,
-}
-
-fn event_type_to_string(event: EventType) -> EventTypeName {
-    use EventTypeName::*;
-    match event {
-        EventType::Info(_) => Info,
-        EventType::SmtpConnected(_) => SmtpConnected,
-        EventType::ImapConnected(_) => ImapConnected,
-        EventType::SmtpMessageSent(_) => SmtpMessageSent,
-        EventType::ImapMessageDeleted(_) => ImapMessageDeleted,
-        EventType::ImapMessageMoved(_) => ImapMessageMoved,
-        EventType::NewBlobFile(_) => NewBlobFile,
-        EventType::DeletedBlobFile(_) => DeletedBlobFile,
-        EventType::Warning(_) => Warning,
-        EventType::Error(_) => Error,
-        EventType::ErrorSelfNotInGroup(_) => ErrorSelfNotInGroup,
-        EventType::MsgsChanged { .. } => MsgsChanged,
-        EventType::IncomingMsg { .. } => IncomingMsg,
-        EventType::MsgsNoticed(_) => MsgsNoticed,
-        EventType::MsgDelivered { .. } => MsgDelivered,
-        EventType::MsgFailed { .. } => MsgFailed,
-        EventType::MsgRead { .. } => MsgRead,
-        EventType::ChatModified(_) => ChatModified,
-        EventType::ChatEphemeralTimerModified { .. } => ChatEphemeralTimerModified,
-        EventType::ContactsChanged(_) => ContactsChanged,
-        EventType::LocationChanged(_) => LocationChanged,
-        EventType::ConfigureProgress { .. } => ConfigureProgress,
-        EventType::ImexProgress(_) => ImexProgress,
-        EventType::ImexFileWritten(_) => ImexFileWritten,
-        EventType::SecurejoinInviterProgress { .. } => SecurejoinInviterProgress,
-        EventType::SecurejoinJoinerProgress { .. } => SecurejoinJoinerProgress,
-        EventType::ConnectivityChanged => ConnectivityChanged,
-        EventType::SelfavatarChanged => SelfavatarChanged,
-        EventType::WebxdcStatusUpdate { .. } => WebxdcStatusUpdate,
-    }
-}
-
-#[cfg(test)]
-#[test]
-fn generate_events_ts_types_definition() {
-    let events = {
-        let mut buf = Vec::new();
-        let options = typescript_type_def::DefinitionFileOptions {
-            root_namespace: None,
-            ..typescript_type_def::DefinitionFileOptions::default()
-        };
-        typescript_type_def::write_definition_file::<_, EventTypeName>(&mut buf, options).unwrap();
-        String::from_utf8(buf).unwrap()
-    };
-    std::fs::write("typescript/generated/events.ts", events).unwrap();
-}

deltachat-jsonrpc/src/api/mod.rs

@@ -1,536 +0,0 @@
-use anyhow::{anyhow, bail, Context, Result};
-use async_std::sync::{Arc, RwLock};
-use deltachat::{
-    chat::{get_chat_msgs, ChatId},
-    chatlist::Chatlist,
-    config::Config,
-    contact::{may_be_valid_addr, Contact, ContactId},
-    context::get_info,
-    message::{Message, MsgId, Viewtype},
-    provider::get_provider_info,
-};
-use std::collections::BTreeMap;
-use std::{collections::HashMap, str::FromStr};
-use yerpc::rpc;
-
-pub use deltachat::accounts::Accounts;
-
-pub mod events;
-pub mod types;
-
-use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
-
-use types::account::Account;
-use types::chat::FullChat;
-use types::chat_list::ChatListEntry;
-use types::contact::ContactObject;
-use types::message::MessageObject;
-use types::provider_info::ProviderInfo;
-
-#[derive(Clone, Debug)]
-pub struct CommandApi {
-    pub(crate) accounts: Arc<RwLock<Accounts>>,
-}
-
-impl CommandApi {
-    pub fn new(accounts: Accounts) -> Self {
-        CommandApi {
-            accounts: Arc::new(RwLock::new(accounts)),
-        }
-    }
-
-    pub fn new_from_arc(accounts: Arc<RwLock<Accounts>>) -> Self {
-        CommandApi { accounts }
-    }
-
-    async fn get_context(&self, id: u32) -> Result<deltachat::context::Context> {
-        let sc = self
-            .accounts
-            .read()
-            .await
-            .get_account(id)
-            .await
-            .ok_or_else(|| anyhow!("account with id {} not found", id))?;
-        Ok(sc)
-    }
-}
-
-#[rpc(all_positional, ts_outdir = "typescript/generated")]
-impl CommandApi {
-    // ---------------------------------------------
-    //  Misc top level functions
-    // ---------------------------------------------
-
-    /// Check if an email address is valid.
-    async fn check_email_validity(&self, email: String) -> bool {
-        may_be_valid_addr(&email)
-    }
-
-    /// Get general system info.
-    async fn get_system_info(&self) -> BTreeMap<&'static str, String> {
-        get_info()
-    }
-
-    // ---------------------------------------------
-    // Account Management
-    // ---------------------------------------------
-
-    async fn add_account(&self) -> Result<u32> {
-        self.accounts.write().await.add_account().await
-    }
-
-    async fn remove_account(&self, account_id: u32) -> Result<()> {
-        self.accounts.write().await.remove_account(account_id).await
-    }
-
-    async fn get_all_account_ids(&self) -> Vec<u32> {
-        self.accounts.read().await.get_all().await
-    }
-
-    /// Select account id for internally selected state.
-    /// TODO: Likely this is deprecated as all methods take an account id now.
-    async fn select_account(&self, id: u32) -> Result<()> {
-        self.accounts.write().await.select_account(id).await
-    }
-
-    /// Get the selected account id of the internal state..
-    /// TODO: Likely this is deprecated as all methods take an account id now.
-    async fn get_selected_account_id(&self) -> Option<u32> {
-        self.accounts.read().await.get_selected_account_id().await
-    }
-
-    /// Get a list of all configured accounts.
-    async fn get_all_accounts(&self) -> Result<Vec<Account>> {
-        let mut accounts = Vec::new();
-        for id in self.accounts.read().await.get_all().await {
-            let context_option = self.accounts.read().await.get_account(id).await;
-            if let Some(ctx) = context_option {
-                accounts.push(Account::from_context(&ctx, id).await?)
-            } else {
-                println!("account with id {} doesn't exist anymore", id);
-            }
-        }
-        Ok(accounts)
-    }
-
-    // ---------------------------------------------
-    // Methods that work on individual accounts
-    // ---------------------------------------------
-
-    /// Get top-level info for an account.
-    async fn get_account_info(&self, account_id: u32) -> Result<Account> {
-        let context_option = self.accounts.read().await.get_account(account_id).await;
-        if let Some(ctx) = context_option {
-            Ok(Account::from_context(&ctx, account_id).await?)
-        } else {
-            Err(anyhow!(
-                "account with id {} doesn't exist anymore",
-                account_id
-            ))
-        }
-    }
-
-    /// Returns provider for the given domain.
-    ///
-    /// This function looks up domain in offline database.
-    ///
-    /// For compatibility, email address can be passed to this function
-    /// instead of the domain.
-    async fn get_provider_info(
-        &self,
-        account_id: u32,
-        email: String,
-    ) -> Result<Option<ProviderInfo>> {
-        let ctx = self.get_context(account_id).await?;
-
-        let socks5_enabled = ctx
-            .get_config_bool(deltachat::config::Config::Socks5Enabled)
-            .await?;
-
-        let provider_info =
-            get_provider_info(&ctx, email.split('@').last().unwrap_or(""), socks5_enabled).await;
-        Ok(ProviderInfo::from_dc_type(provider_info))
-    }
-
-    /// Checks if the context is already configured.
-    async fn is_configured(&self, account_id: u32) -> Result<bool> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.is_configured().await
-    }
-
-    /// Get system info for an account.
-    async fn get_info(&self, account_id: u32) -> Result<BTreeMap<&'static str, String>> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.get_info().await
-    }
-
-    async fn set_config(&self, account_id: u32, key: String, value: Option<String>) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        set_config(&ctx, &key, value.as_deref()).await
-    }
-
-    async fn batch_set_config(
-        &self,
-        account_id: u32,
-        config: HashMap<String, Option<String>>,
-    ) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        for (key, value) in config.into_iter() {
-            set_config(&ctx, &key, value.as_deref())
-                .await
-                .with_context(|| format!("Can't set {} to {:?}", key, value))?;
-        }
-        Ok(())
-    }
-
-    async fn get_config(&self, account_id: u32, key: String) -> Result<Option<String>> {
-        let ctx = self.get_context(account_id).await?;
-        get_config(&ctx, &key).await
-    }
-
-    async fn batch_get_config(
-        &self,
-        account_id: u32,
-        keys: Vec<String>,
-    ) -> Result<HashMap<String, Option<String>>> {
-        let ctx = self.get_context(account_id).await?;
-        let mut result: HashMap<String, Option<String>> = HashMap::new();
-        for key in keys {
-            result.insert(key.clone(), get_config(&ctx, &key).await?);
-        }
-        Ok(result)
-    }
-
-    /// Configures this account with the currently set parameters.
-    /// Setup the credential config before calling this.
-    async fn configure(&self, account_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.stop_io().await;
-        ctx.configure().await?;
-        ctx.start_io().await;
-        Ok(())
-    }
-
-    /// Signal an ongoing process to stop.
-    async fn stop_ongoing_process(&self, account_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ctx.stop_ongoing().await;
-        Ok(())
-    }
-
-    // ---------------------------------------------
-    //  autocrypt
-    // ---------------------------------------------
-
-    async fn autocrypt_initiate_key_transfer(&self, account_id: u32) -> Result<String> {
-        let ctx = self.get_context(account_id).await?;
-        deltachat::imex::initiate_key_transfer(&ctx).await
-    }
-
-    async fn autocrypt_continue_key_transfer(
-        &self,
-        account_id: u32,
-        message_id: u32,
-        setup_code: String,
-    ) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        deltachat::imex::continue_key_transfer(&ctx, MsgId::new(message_id), &setup_code).await
-    }
-
-    // ---------------------------------------------
-    //   chat list
-    // ---------------------------------------------
-
-    async fn get_chatlist_entries(
-        &self,
-        account_id: u32,
-        list_flags: Option<u32>,
-        query_string: Option<String>,
-        query_contact_id: Option<u32>,
-    ) -> Result<Vec<ChatListEntry>> {
-        let ctx = self.get_context(account_id).await?;
-        let list = Chatlist::try_load(
-            &ctx,
-            list_flags.unwrap_or(0) as usize,
-            query_string.as_deref(),
-            query_contact_id.map(ContactId::new),
-        )
-        .await?;
-        let mut l: Vec<ChatListEntry> = Vec::new();
-        for i in 0..list.len() {
-            l.push(ChatListEntry(
-                list.get_chat_id(i)?.to_u32(),
-                list.get_msg_id(i)?.unwrap_or_default().to_u32(),
-            ));
-        }
-        Ok(l)
-    }
-
-    async fn get_chatlist_items_by_entries(
-        &self,
-        account_id: u32,
-        entries: Vec<ChatListEntry>,
-    ) -> Result<HashMap<u32, ChatListItemFetchResult>> {
-        // todo custom json deserializer for ChatListEntry?
-        let ctx = self.get_context(account_id).await?;
-        let mut result: HashMap<u32, ChatListItemFetchResult> = HashMap::new();
-        for (_i, entry) in entries.iter().enumerate() {
-            result.insert(
-                entry.0,
-                match get_chat_list_item_by_id(&ctx, entry).await {
-                    Ok(res) => res,
-                    Err(err) => ChatListItemFetchResult::Error {
-                        id: entry.0,
-                        error: format!("{:?}", err),
-                    },
-                },
-            );
-        }
-        Ok(result)
-    }
-
-    // ---------------------------------------------
-    //  chat
-    // ---------------------------------------------
-
-    async fn chatlist_get_full_chat_by_id(
-        &self,
-        account_id: u32,
-        chat_id: u32,
-    ) -> Result<FullChat> {
-        let ctx = self.get_context(account_id).await?;
-        FullChat::from_dc_chat_id(&ctx, chat_id).await
-    }
-
-    async fn accept_chat(&self, account_id: u32, chat_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ChatId::new(chat_id).accept(&ctx).await
-    }
-
-    async fn block_chat(&self, account_id: u32, chat_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        ChatId::new(chat_id).block(&ctx).await
-    }
-
-    // ---------------------------------------------
-    // message list
-    // ---------------------------------------------
-
-    async fn message_list_get_message_ids(
-        &self,
-        account_id: u32,
-        chat_id: u32,
-        flags: u32,
-    ) -> Result<Vec<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let msg = get_chat_msgs(&ctx, ChatId::new(chat_id), flags).await?;
-        Ok(msg
-            .iter()
-            .filter_map(|chat_item| match chat_item {
-                deltachat::chat::ChatItem::Message { msg_id } => Some(msg_id.to_u32()),
-                _ => None,
-            })
-            .collect())
-    }
-
-    async fn message_get_message(&self, account_id: u32, message_id: u32) -> Result<MessageObject> {
-        let ctx = self.get_context(account_id).await?;
-        MessageObject::from_message_id(&ctx, message_id).await
-    }
-
-    async fn message_get_messages(
-        &self,
-        account_id: u32,
-        message_ids: Vec<u32>,
-    ) -> Result<HashMap<u32, MessageObject>> {
-        let ctx = self.get_context(account_id).await?;
-        let mut messages: HashMap<u32, MessageObject> = HashMap::new();
-        for message_id in message_ids {
-            messages.insert(
-                message_id,
-                MessageObject::from_message_id(&ctx, message_id).await?,
-            );
-        }
-        Ok(messages)
-    }
-
-    // ---------------------------------------------
-    //  contact
-    // ---------------------------------------------
-
-    /// Get a single contact options by ID.
-    async fn contacts_get_contact(
-        &self,
-        account_id: u32,
-        contact_id: u32,
-    ) -> Result<ContactObject> {
-        let ctx = self.get_context(account_id).await?;
-        let contact_id = ContactId::new(contact_id);
-
-        ContactObject::from_dc_contact(
-            &ctx,
-            deltachat::contact::Contact::get_by_id(&ctx, contact_id).await?,
-        )
-        .await
-    }
-
-    /// Add a single contact as a result of an explicit user action.
-    ///
-    /// Returns contact id of the created or existing contact
-    async fn contacts_create_contact(
-        &self,
-        account_id: u32,
-        email: String,
-        name: Option<String>,
-    ) -> Result<u32> {
-        let ctx = self.get_context(account_id).await?;
-        if !may_be_valid_addr(&email) {
-            bail!(anyhow!(
-                "provided email address is not a valid email address"
-            ))
-        }
-        let contact_id = Contact::create(&ctx, &name.unwrap_or_default(), &email).await?;
-        Ok(contact_id.to_u32())
-    }
-
-    /// Returns contact id of the created or existing DM chat with that contact
-    async fn contacts_create_chat_by_contact_id(
-        &self,
-        account_id: u32,
-        contact_id: u32,
-    ) -> Result<u32> {
-        let ctx = self.get_context(account_id).await?;
-        let contact = Contact::get_by_id(&ctx, ContactId::new(contact_id)).await?;
-        ChatId::create_for_contact(&ctx, contact.id)
-            .await
-            .map(|id| id.to_u32())
-    }
-
-    async fn contacts_block(&self, account_id: u32, contact_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        Contact::block(&ctx, ContactId::new(contact_id)).await
-    }
-
-    async fn contacts_unblock(&self, account_id: u32, contact_id: u32) -> Result<()> {
-        let ctx = self.get_context(account_id).await?;
-        Contact::unblock(&ctx, ContactId::new(contact_id)).await
-    }
-
-    async fn contacts_get_blocked(&self, account_id: u32) -> Result<Vec<ContactObject>> {
-        let ctx = self.get_context(account_id).await?;
-        let blocked_ids = Contact::get_all_blocked(&ctx).await?;
-        let mut contacts: Vec<ContactObject> = Vec::with_capacity(blocked_ids.len());
-        for id in blocked_ids {
-            contacts.push(
-                ContactObject::from_dc_contact(
-                    &ctx,
-                    deltachat::contact::Contact::get_by_id(&ctx, id).await?,
-                )
-                .await?,
-            );
-        }
-        Ok(contacts)
-    }
-
-    async fn contacts_get_contact_ids(
-        &self,
-        account_id: u32,
-        list_flags: u32,
-        query: Option<String>,
-    ) -> Result<Vec<u32>> {
-        let ctx = self.get_context(account_id).await?;
-        let contacts = Contact::get_all(&ctx, list_flags, query.as_deref()).await?;
-        Ok(contacts.into_iter().map(|c| c.to_u32()).collect())
-    }
-
-    /// Get a list of contacts.
-    /// (formerly called getContacts2 in desktop)
-    async fn contacts_get_contacts(
-        &self,
-        account_id: u32,
-        list_flags: u32,
-        query: Option<String>,
-    ) -> Result<Vec<ContactObject>> {
-        let ctx = self.get_context(account_id).await?;
-        let contact_ids = Contact::get_all(&ctx, list_flags, query.as_deref()).await?;
-        let mut contacts: Vec<ContactObject> = Vec::with_capacity(contact_ids.len());
-        for id in contact_ids {
-            contacts.push(
-                ContactObject::from_dc_contact(
-                    &ctx,
-                    deltachat::contact::Contact::get_by_id(&ctx, id).await?,
-                )
-                .await?,
-            );
-        }
-        Ok(contacts)
-    }
-
-    async fn contacts_get_contacts_by_ids(
-        &self,
-        account_id: u32,
-        ids: Vec<u32>,
-    ) -> Result<HashMap<u32, ContactObject>> {
-        let ctx = self.get_context(account_id).await?;
-
-        let mut contacts = HashMap::with_capacity(ids.len());
-        for id in ids {
-            contacts.insert(
-                id,
-                ContactObject::from_dc_contact(
-                    &ctx,
-                    deltachat::contact::Contact::get_by_id(&ctx, ContactId::new(id)).await?,
-                )
-                .await?,
-            );
-        }
-        Ok(contacts)
-    }
-
-    // ---------------------------------------------
-    //           misc prototyping functions
-    //       that might get removed later again
-    // ---------------------------------------------
-
-    /// Returns the messageid of the sent message
-    async fn misc_send_text_message(
-        &self,
-        account_id: u32,
-        text: String,
-        chat_id: u32,
-    ) -> Result<u32> {
-        let ctx = self.get_context(account_id).await?;
-
-        let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(Some(text));
-
-        let message_id = deltachat::chat::send_msg(&ctx, ChatId::new(chat_id), &mut msg).await?;
-        Ok(message_id.to_u32())
-    }
-}
-
-// Helper functions (to prevent code duplication)
-async fn set_config(
-    ctx: &deltachat::context::Context,
-    key: &str,
-    value: Option<&str>,
-) -> Result<(), anyhow::Error> {
-    if key.starts_with("ui.") {
-        ctx.set_ui_config(key, value).await
-    } else {
-        ctx.set_config(Config::from_str(key).context("unknown key")?, value)
-            .await
-    }
-}
-
-async fn get_config(
-    ctx: &deltachat::context::Context,
-    key: &str,
-) -> Result<Option<String>, anyhow::Error> {
-    if key.starts_with("ui.") {
-        ctx.get_ui_config(key).await
-    } else {
-        ctx.get_config(Config::from_str(key).context("unknown key")?)
-            .await
-    }
-}

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

@@ -1,46 +0,0 @@
-use anyhow::Result;
-use deltachat::config::Config;
-use deltachat::contact::{Contact, ContactId};
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-use super::color_int_to_hex_string;
-
-#[derive(Serialize, TypeDef)]
-#[serde(tag = "type")]
-pub enum Account {
-    //#[serde(rename_all = "camelCase")]
-    Configured {
-        id: u32,
-        display_name: Option<String>,
-        addr: Option<String>,
-        // size: u32,
-        profile_image: Option<String>, // TODO: This needs to be converted to work with blob http server.
-        color: String,
-    },
-    Unconfigured {
-        id: u32,
-    },
-}
-
-impl Account {
-    pub async fn from_context(ctx: &deltachat::context::Context, id: u32) -> Result<Self> {
-        if ctx.is_configured().await? {
-            let display_name = ctx.get_config(Config::Displayname).await?;
-            let addr = ctx.get_config(Config::Addr).await?;
-            let profile_image = ctx.get_config(Config::Selfavatar).await?;
-            let color = color_int_to_hex_string(
-                Contact::get_by_id(ctx, ContactId::SELF).await?.get_color(),
-            );
-            Ok(Account::Configured {
-                id,
-                display_name,
-                addr,
-                profile_image,
-                color,
-            })
-        } else {
-            Ok(Account::Unconfigured { id })
-        }
-    }
-}

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

@@ -1,91 +0,0 @@
-use anyhow::{anyhow, Result};
-use deltachat::chat::get_chat_contacts;
-use deltachat::chat::{Chat, ChatId};
-use deltachat::contact::{Contact, ContactId};
-use deltachat::context::Context;
-use num_traits::cast::ToPrimitive;
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-use super::color_int_to_hex_string;
-use super::contact::ContactObject;
-
-#[derive(Serialize, TypeDef)]
-pub struct FullChat {
-    id: u32,
-    name: String,
-    is_protected: bool,
-    profile_image: Option<String>, //BLOBS ?
-    archived: bool,
-    // subtitle  - will be moved to frontend because it uses translation functions
-    chat_type: u32,
-    is_unpromoted: bool,
-    is_self_talk: bool,
-    contacts: Vec<ContactObject>,
-    contact_ids: Vec<u32>,
-    color: String,
-    fresh_message_counter: usize,
-    // is_group - please check over chat.type in frontend instead
-    is_contact_request: bool,
-    is_device_chat: bool,
-    self_in_group: bool,
-    is_muted: bool,
-    ephemeral_timer: u32, //TODO look if there are more important properties in newer core versions
-    can_send: bool,
-}
-
-impl FullChat {
-    pub async fn from_dc_chat_id(context: &Context, chat_id: u32) -> Result<Self> {
-        let rust_chat_id = ChatId::new(chat_id);
-        let chat = Chat::load_from_db(context, rust_chat_id).await?;
-
-        let contact_ids = get_chat_contacts(context, rust_chat_id).await?;
-
-        let mut contacts = Vec::new();
-
-        for contact_id in &contact_ids {
-            contacts.push(
-                ContactObject::from_dc_contact(
-                    context,
-                    Contact::load_from_db(context, *contact_id).await?,
-                )
-                .await?,
-            )
-        }
-
-        let profile_image = match chat.get_profile_image(context).await? {
-            Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
-            None => None,
-        };
-
-        let color = color_int_to_hex_string(chat.get_color(context).await?);
-        let fresh_message_counter = rust_chat_id.get_fresh_msg_cnt(context).await?;
-        let ephemeral_timer = rust_chat_id.get_ephemeral_timer(context).await?.to_u32();
-
-        let can_send = chat.can_send(context).await?;
-
-        Ok(FullChat {
-            id: chat_id,
-            name: chat.name.clone(),
-            is_protected: chat.is_protected(),
-            profile_image, //BLOBS ?
-            archived: chat.get_visibility() == deltachat::chat::ChatVisibility::Archived,
-            chat_type: chat
-                .get_type()
-                .to_u32()
-                .ok_or_else(|| anyhow!("unknown chat type id"))?, // TODO get rid of this unwrap?
-            is_unpromoted: chat.is_unpromoted(),
-            is_self_talk: chat.is_self_talk(),
-            contacts,
-            contact_ids: contact_ids.iter().map(|id| id.to_u32()).collect(),
-            color,
-            fresh_message_counter,
-            is_contact_request: chat.is_contact_request(),
-            is_device_chat: chat.is_device_talk(),
-            self_in_group: contact_ids.contains(&ContactId::SELF),
-            is_muted: chat.is_muted(),
-            ephemeral_timer,
-            can_send,
-        })
-    }
-}

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

@@ -1,117 +0,0 @@
-use anyhow::Result;
-use deltachat::constants::*;
-use deltachat::contact::ContactId;
-use deltachat::{
-    chat::{get_chat_contacts, ChatVisibility},
-    chatlist::Chatlist,
-};
-use deltachat::{
-    chat::{Chat, ChatId},
-    message::MsgId,
-};
-use num_traits::cast::ToPrimitive;
-use serde::{Deserialize, Serialize};
-use typescript_type_def::TypeDef;
-
-use super::color_int_to_hex_string;
-
-#[derive(Deserialize, Serialize, TypeDef)]
-pub struct ChatListEntry(pub u32, pub u32);
-
-#[derive(Serialize, TypeDef)]
-#[serde(tag = "type")]
-pub enum ChatListItemFetchResult {
-    #[serde(rename_all = "camelCase")]
-    ChatListItem {
-        id: u32,
-        name: String,
-        avatar_path: Option<String>,
-        color: String,
-        last_updated: Option<i64>,
-        summary_text1: String,
-        summary_text2: String,
-        summary_status: u32,
-        is_protected: bool,
-        is_group: bool,
-        fresh_message_counter: usize,
-        is_self_talk: bool,
-        is_device_talk: bool,
-        is_sending_location: bool,
-        is_self_in_group: bool,
-        is_archived: bool,
-        is_pinned: bool,
-        is_muted: bool,
-        is_contact_request: bool,
-    },
-    ArchiveLink,
-    #[serde(rename_all = "camelCase")]
-    Error {
-        id: u32,
-        error: String,
-    },
-}
-
-pub(crate) async fn get_chat_list_item_by_id(
-    ctx: &deltachat::context::Context,
-    entry: &ChatListEntry,
-) -> Result<ChatListItemFetchResult> {
-    let chat_id = ChatId::new(entry.0);
-    let last_msgid = match entry.1 {
-        0 => None,
-        _ => Some(MsgId::new(entry.1)),
-    };
-
-    if chat_id.is_archived_link() {
-        return Ok(ChatListItemFetchResult::ArchiveLink);
-    }
-
-    let chat = Chat::load_from_db(ctx, chat_id).await?;
-    let summary = Chatlist::get_summary2(ctx, chat_id, last_msgid, Some(&chat)).await?;
-
-    let summary_text1 = summary.prefix.map_or_else(String::new, |s| s.to_string());
-    let summary_text2 = summary.text.to_owned();
-
-    let visibility = chat.get_visibility();
-
-    let avatar_path = chat
-        .get_profile_image(ctx)
-        .await?
-        .map(|path| path.to_str().unwrap_or("invalid/path").to_owned());
-
-    let last_updated = match last_msgid {
-        Some(id) => {
-            let last_message = deltachat::message::Message::load_from_db(ctx, id).await?;
-            Some(last_message.get_timestamp() * 1000)
-        }
-        None => None,
-    };
-
-    let self_in_group = get_chat_contacts(ctx, chat_id)
-        .await?
-        .contains(&ContactId::SELF);
-
-    let fresh_message_counter = chat_id.get_fresh_msg_cnt(ctx).await?;
-    let color = color_int_to_hex_string(chat.get_color(ctx).await?);
-
-    Ok(ChatListItemFetchResult::ChatListItem {
-        id: chat_id.to_u32(),
-        name: chat.get_name().to_owned(),
-        avatar_path,
-        color,
-        last_updated,
-        summary_text1,
-        summary_text2,
-        summary_status: summary.state.to_u32().expect("impossible"), // idea and a function to transform the constant to strings? or return string enum
-        is_protected: chat.is_protected(),
-        is_group: chat.get_type() == Chattype::Group,
-        fresh_message_counter,
-        is_self_talk: chat.is_self_talk(),
-        is_device_talk: chat.is_device_talk(),
-        is_self_in_group: self_in_group,
-        is_sending_location: chat.is_sending_locations(),
-        is_archived: visibility == ChatVisibility::Archived,
-        is_pinned: visibility == ChatVisibility::Pinned,
-        is_muted: chat.is_muted(),
-        is_contact_request: chat.is_contact_request(),
-    })
-}

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

@@ -1,50 +0,0 @@
-use anyhow::Result;
-use deltachat::contact::VerifiedStatus;
-use deltachat::context::Context;
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-use super::color_int_to_hex_string;
-
-#[derive(Serialize, TypeDef)]
-#[serde(rename = "Contact")]
-pub struct ContactObject {
-    address: String,
-    color: String,
-    auth_name: String,
-    status: String,
-    display_name: String,
-    id: u32,
-    name: String,
-    profile_image: Option<String>, // BLOBS
-    name_and_addr: String,
-    is_blocked: bool,
-    is_verified: bool,
-}
-
-impl ContactObject {
-    pub async fn from_dc_contact(
-        context: &Context,
-        contact: deltachat::contact::Contact,
-    ) -> Result<Self> {
-        let profile_image = match contact.get_profile_image(context).await? {
-            Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
-            None => None,
-        };
-        let is_verified = contact.is_verified(context).await? == VerifiedStatus::BidirectVerified;
-
-        Ok(ContactObject {
-            address: contact.get_addr().to_owned(),
-            color: color_int_to_hex_string(contact.get_color()),
-            auth_name: contact.get_authname().to_owned(),
-            status: contact.get_status().to_owned(),
-            display_name: contact.get_display_name().to_owned(),
-            id: contact.id.to_u32(),
-            name: contact.get_name().to_owned(),
-            profile_image, //BLOBS
-            name_and_addr: contact.get_name_n_addr(),
-            is_blocked: contact.is_blocked(),
-            is_verified,
-        })
-    }
-}

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

@@ -1,127 +0,0 @@
-use anyhow::{anyhow, Result};
-use deltachat::contact::Contact;
-use deltachat::context::Context;
-use deltachat::message::Message;
-use deltachat::message::MsgId;
-use num_traits::cast::ToPrimitive;
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-use super::contact::ContactObject;
-
-#[derive(Serialize, TypeDef)]
-#[serde(rename = "Message")]
-pub struct MessageObject {
-    id: u32,
-    chat_id: u32,
-    from_id: u32,
-    quoted_text: Option<String>,
-    quoted_message_id: Option<u32>,
-    text: Option<String>,
-    has_location: bool,
-    has_html: bool,
-    view_type: u32,
-    state: u32,
-
-    timestamp: i64,
-    sort_timestamp: i64,
-    received_timestamp: i64,
-    has_deviating_timestamp: bool,
-
-    // summary - use/create another function if you need it
-    subject: String,
-    show_padlock: bool,
-    is_setupmessage: bool,
-    is_info: bool,
-    is_forwarded: bool,
-
-    duration: i32,
-    dimensions_height: i32,
-    dimensions_width: i32,
-
-    videochat_type: Option<u32>,
-    videochat_url: Option<String>,
-
-    override_sender_name: Option<String>,
-    sender: ContactObject,
-
-    setup_code_begin: Option<String>,
-
-    file: Option<String>,
-    file_mime: Option<String>,
-    file_bytes: u64,
-    file_name: Option<String>,
-}
-
-impl MessageObject {
-    pub async fn from_message_id(context: &Context, message_id: u32) -> Result<Self> {
-        let msg_id = MsgId::new(message_id);
-        let message = Message::load_from_db(context, msg_id).await?;
-
-        let quoted_message_id = message
-            .quoted_message(context)
-            .await?
-            .map(|m| m.get_id().to_u32());
-
-        let sender_contact = Contact::load_from_db(context, message.get_from_id()).await?;
-        let sender = ContactObject::from_dc_contact(context, sender_contact).await?;
-        let file_bytes = message.get_filebytes(context).await;
-        let override_sender_name = message.get_override_sender_name();
-
-        Ok(MessageObject {
-            id: message_id,
-            chat_id: message.get_chat_id().to_u32(),
-            from_id: message.get_from_id().to_u32(),
-            quoted_text: message.quoted_text(),
-            quoted_message_id,
-            text: message.get_text(),
-            has_location: message.has_location(),
-            has_html: message.has_html(),
-            view_type: message
-                .get_viewtype()
-                .to_u32()
-                .ok_or_else(|| anyhow!("viewtype conversion to number failed"))?,
-            state: message
-                .get_state()
-                .to_u32()
-                .ok_or_else(|| anyhow!("state conversion to number failed"))?,
-
-            timestamp: message.get_timestamp(),
-            sort_timestamp: message.get_sort_timestamp(),
-            received_timestamp: message.get_received_timestamp(),
-            has_deviating_timestamp: message.has_deviating_timestamp(),
-
-            subject: message.get_subject().to_owned(),
-            show_padlock: message.get_showpadlock(),
-            is_setupmessage: message.is_setupmessage(),
-            is_info: message.is_info(),
-            is_forwarded: message.is_forwarded(),
-
-            duration: message.get_duration(),
-            dimensions_height: message.get_height(),
-            dimensions_width: message.get_width(),
-
-            videochat_type: match message.get_videochat_type() {
-                Some(vct) => Some(
-                    vct.to_u32()
-                        .ok_or_else(|| anyhow!("state conversion to number failed"))?,
-                ),
-                None => None,
-            },
-            videochat_url: message.get_videochat_url(),
-
-            override_sender_name,
-            sender,
-
-            setup_code_begin: message.get_setupcodebegin(context).await,
-
-            file: match message.get_file(context) {
-                Some(path_buf) => path_buf.to_str().map(|s| s.to_owned()),
-                None => None,
-            }, //BLOBS
-            file_mime: message.get_filemime(),
-            file_bytes,
-            file_name: message.get_filename(),
-        })
-    }
-}

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

@@ -1,10 +0,0 @@
-pub mod account;
-pub mod chat;
-pub mod chat_list;
-pub mod contact;
-pub mod message;
-pub mod provider_info;
-
-pub fn color_int_to_hex_string(color: u32) -> String {
-    format!("{:#08x}", color).replace("0x", "#")
-}

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

@@ -1,21 +0,0 @@
-use deltachat::provider::Provider;
-use num_traits::cast::ToPrimitive;
-use serde::Serialize;
-use typescript_type_def::TypeDef;
-
-#[derive(Serialize, TypeDef)]
-pub struct ProviderInfo {
-    pub before_login_hint: String,
-    pub overview_page: String,
-    pub status: u32, // in reality this is an enum, but for simlicity and because it gets converted into a number anyway, we use an u32 here.
-}
-
-impl ProviderInfo {
-    pub fn from_dc_type(provider: Option<&Provider>) -> Option<Self> {
-        provider.map(|p| ProviderInfo {
-            before_login_hint: p.before_login_hint.to_owned(),
-            overview_page: p.overview_page.to_owned(),
-            status: p.status.to_u32().unwrap(),
-        })
-    }
-}

deltachat-jsonrpc/src/lib.rs

@@ -1,60 +0,0 @@
-pub mod api;
-pub use api::events;
-
-pub use yerpc;
-
-#[cfg(test)]
-mod tests {
-    use super::api::{Accounts, CommandApi};
-    use async_channel::unbounded;
-    use async_std::task;
-    use futures::StreamExt;
-    use tempfile::TempDir;
-    use yerpc::{MessageHandle, RpcHandle};
-
-    #[async_std::test]
-    async fn basic_json_rpc_functionality() -> anyhow::Result<()> {
-        // println!("{}", "");
-        let tmp_dir = TempDir::new().unwrap().path().into();
-        println!("tmp_dir: {:?}", tmp_dir);
-
-        let accounts = Accounts::new(tmp_dir).await?;
-        let cmd_api = CommandApi::new(accounts);
-
-        let (sender, mut receiver) = unbounded::<String>();
-
-        let (request_handle, mut rx) = RpcHandle::new();
-        let session = cmd_api;
-        let handle = MessageHandle::new(request_handle, session);
-        task::spawn({
-            async move {
-                while let Some(message) = rx.next().await {
-                    let message = serde_json::to_string(&message)?;
-                    // Abort serialization on error.
-                    sender.send(message).await?;
-                }
-                let res: Result<(), anyhow::Error> = Ok(());
-                res
-            }
-        });
-
-        {
-            let request = r#"{"jsonrpc":"2.0","method":"add_account","params":[],"id":1}"#;
-            let response = r#"{"jsonrpc":"2.0","id":1,"result":1}"#;
-            handle.handle_message(request).await;
-            let result = receiver.next().await;
-            println!("{:?}", result);
-            assert_eq!(result, Some(response.to_owned()));
-        }
-        {
-            let request = r#"{"jsonrpc":"2.0","method":"get_all_account_ids","params":[],"id":2}"#;
-            let response = r#"{"jsonrpc":"2.0","id":2,"result":[1]}"#;
-            handle.handle_message(request).await;
-            let result = receiver.next().await;
-            println!("{:?}", result);
-            assert_eq!(result, Some(response.to_owned()));
-        }
-
-        Ok(())
-    }
-}

deltachat-jsonrpc/src/webserver.rs

@@ -1,44 +0,0 @@
-use async_std::path::PathBuf;
-use async_std::task;
-use tide::Request;
-use yerpc::RpcHandle;
-use yerpc_tide::yerpc_handler;
-
-mod api;
-use api::events::event_to_json_rpc_notification;
-use api::{Accounts, CommandApi};
-
-#[async_std::main]
-async fn main() -> Result<(), std::io::Error> {
-    env_logger::init();
-    log::info!("Starting");
-
-    let accounts = Accounts::new(PathBuf::from("./accounts")).await.unwrap();
-    let state = CommandApi::new(accounts);
-
-    let mut app = tide::with_state(state.clone());
-    app.at("/ws").get(yerpc_handler(request_handler));
-
-    state.accounts.read().await.start_io().await;
-    app.listen("127.0.0.1:20808").await?;
-
-    Ok(())
-}
-async fn request_handler(
-    request: Request<CommandApi>,
-    rpc: RpcHandle,
-) -> anyhow::Result<CommandApi> {
-    let state = request.state().clone();
-    task::spawn(event_loop(state.clone(), rpc));
-    Ok(state)
-}
-
-async fn event_loop(state: CommandApi, rpc: RpcHandle) -> anyhow::Result<()> {
-    let events = state.accounts.read().await.get_event_emitter().await;
-    while let Some(event) = events.recv().await {
-        // log::debug!("event {:?}", event);
-        let event = event_to_json_rpc_notification(event);
-        rpc.notify("event", Some(event)).await?;
-    }
-    Ok(())
-}

deltachat-jsonrpc/typescript/.gitignore

@@ -1,6 +0,0 @@
-node_modules
-dist
-test_dist
-coverage
-yarn.lock
-package-lock.json

deltachat-jsonrpc/typescript/.prettierignore

@@ -1,3 +0,0 @@
-coverage
-dist
-generated

deltachat-jsonrpc/typescript/deltachat.ts

@@ -1 +0,0 @@
-export * from "./src/lib.js";

deltachat-jsonrpc/typescript/example.ts

@@ -1,107 +0,0 @@
-import { RawClient, RPC } from "./src/lib";
-import { WebsocketTransport, Request } from "yerpc";
-
-type DeltaEvent = { id: string; contextId: number; field1: any; field2: any };
-var selectedAccount = 0;
-window.addEventListener("DOMContentLoaded", (_event) => {
-  (window as any).selectDeltaAccount = (id: string) => {
-    selectedAccount = Number(id);
-    window.dispatchEvent(new Event("account-changed"));
-  };
-  run().catch((err) => console.error("run failed", err));
-});
-
-async function run() {
-  const $main = document.getElementById("main")!;
-  const $side = document.getElementById("side")!;
-  const $head = document.getElementById("header")!;
-
-  const transport = new WebsocketTransport("ws://localhost:20808/ws");
-  const client = new RawClient(transport);
-
-  (window as any).client = client;
-
-  transport.on("request", (request: Request) => {
-    const method = request.method;
-    if (method === "event") {
-      const params = request.params! as DeltaEvent;
-      onIncomingEvent(params, params.id);
-    }
-  });
-
-  window.addEventListener("account-changed", async (_event: Event) => {
-    await client.selectAccount(selectedAccount);
-    listChatsForSelectedAccount();
-  });
-
-  await Promise.all([loadAccountsInHeader(), listChatsForSelectedAccount()]);
-
-  async function loadAccountsInHeader() {
-    const accounts = await client.getAllAccounts();
-    for (const account of accounts) {
-      if (account.type === "Configured") {
-        write(
-          $head,
-          `<a href="#" onclick="selectDeltaAccount(${account.id})">
-          ${account.addr!}
-          </a>&nbsp;`
-        );
-      }
-    }
-  }
-
-  async function listChatsForSelectedAccount() {
-    clear($main);
-    const selectedAccount = await client.getSelectedAccountId();
-    if (!selectedAccount) return write($main, "No account selected");
-    const info = await client.getAccountInfo(selectedAccount);
-    if (info.type !== "Configured") {
-      return write($main, "Account is not configured");
-    }
-    write($main, `<h2>${info.addr!}</h2>`);
-    const chats = await client.getChatlistEntries(
-      selectedAccount,
-      0,
-      null,
-      null
-    );
-    for (const [chatId, _messageId] of chats) {
-      const chat = await client.chatlistGetFullChatById(
-        selectedAccount,
-        chatId
-      );
-      write($main, `<h3>${chat.name}</h3>`);
-      const messageIds = await client.messageListGetMessageIds(
-        selectedAccount,
-        chatId,
-        0
-      );
-      const messages = await client.messageGetMessages(
-        selectedAccount,
-        messageIds
-      );
-      for (const [_messageId, message] of Object.entries(messages)) {
-        write($main, `<p>${message.text}</p>`);
-      }
-    }
-  }
-
-  function onIncomingEvent(event: DeltaEvent, name: string) {
-    write(
-      $side,
-      `
-        <p class="message">
-          [<strong>${name}</strong> on account ${event.contextId}]<br>
-          <em>f1:</em> ${JSON.stringify(event.field1)}<br>
-          <em>f2:</em> ${JSON.stringify(event.field2)}
-        </p>`
-    );
-  }
-}
-
-function write(el: HTMLElement, html: string) {
-  el.innerHTML += html;
-}
-function clear(el: HTMLElement) {
-  el.innerHTML = "";
-}

deltachat-jsonrpc/typescript/generated/client.ts

@@ -1,251 +0,0 @@
-// AUTO-GENERATED by yerpc-derive
-
-import * as T from "./types.js"
-import * as RPC from "./jsonrpc.js"
-
-type RequestMethod = (method: string, params?: RPC.Params) => Promise<unknown>;
-type NotificationMethod = (method: string, params?: RPC.Params) => void;
-
-interface Transport {
-  request: RequestMethod,
-  notification: NotificationMethod
-}
-
-export class RawClient {
-  constructor(private _transport: Transport) {}
-
-  /**
-   * Check if an email address is valid.
-   */
-  public checkEmailValidity(email: string): Promise<boolean> {
-    return (this._transport.request('check_email_validity', [email] as RPC.Params)) as Promise<boolean>;
-  }
-
-  /**
-   * Get general system info.
-   */
-  public getSystemInfo(): Promise<Record<string,string>> {
-    return (this._transport.request('get_system_info', [] as RPC.Params)) as Promise<Record<string,string>>;
-  }
-
-
-  public addAccount(): Promise<T.U32> {
-    return (this._transport.request('add_account', [] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public removeAccount(accountId: T.U32): Promise<null> {
-    return (this._transport.request('remove_account', [accountId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getAllAccountIds(): Promise<(T.U32)[]> {
-    return (this._transport.request('get_all_account_ids', [] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-  /**
-   * Select account id for internally selected state.
-   * TODO: Likely this is deprecated as all methods take an account id now.
-   */
-  public selectAccount(id: T.U32): Promise<null> {
-    return (this._transport.request('select_account', [id] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Get the selected account id of the internal state..
-   * TODO: Likely this is deprecated as all methods take an account id now.
-   */
-  public getSelectedAccountId(): Promise<(T.U32|null)> {
-    return (this._transport.request('get_selected_account_id', [] as RPC.Params)) as Promise<(T.U32|null)>;
-  }
-
-  /**
-   * Get a list of all configured accounts.
-   */
-  public getAllAccounts(): Promise<(T.Account)[]> {
-    return (this._transport.request('get_all_accounts', [] as RPC.Params)) as Promise<(T.Account)[]>;
-  }
-
-  /**
-   * Get top-level info for an account.
-   */
-  public getAccountInfo(accountId: T.U32): Promise<T.Account> {
-    return (this._transport.request('get_account_info', [accountId] as RPC.Params)) as Promise<T.Account>;
-  }
-
-  /**
-   * Returns provider for the given domain.
-   *
-   * This function looks up domain in offline database.
-   *
-   * For compatibility, email address can be passed to this function
-   * instead of the domain.
-   */
-  public getProviderInfo(accountId: T.U32, email: string): Promise<(T.ProviderInfo|null)> {
-    return (this._transport.request('get_provider_info', [accountId, email] as RPC.Params)) as Promise<(T.ProviderInfo|null)>;
-  }
-
-  /**
-   * Checks if the context is already configured.
-   */
-  public isConfigured(accountId: T.U32): Promise<boolean> {
-    return (this._transport.request('is_configured', [accountId] as RPC.Params)) as Promise<boolean>;
-  }
-
-  /**
-   * Get system info for an account.
-   */
-  public getInfo(accountId: T.U32): Promise<Record<string,string>> {
-    return (this._transport.request('get_info', [accountId] as RPC.Params)) as Promise<Record<string,string>>;
-  }
-
-
-  public setConfig(accountId: T.U32, key: string, value: (string|null)): Promise<null> {
-    return (this._transport.request('set_config', [accountId, key, value] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public batchSetConfig(accountId: T.U32, config: Record<string,(string|null)>): Promise<null> {
-    return (this._transport.request('batch_set_config', [accountId, config] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getConfig(accountId: T.U32, key: string): Promise<(string|null)> {
-    return (this._transport.request('get_config', [accountId, key] as RPC.Params)) as Promise<(string|null)>;
-  }
-
-
-  public batchGetConfig(accountId: T.U32, keys: (string)[]): Promise<Record<string,(string|null)>> {
-    return (this._transport.request('batch_get_config', [accountId, keys] as RPC.Params)) as Promise<Record<string,(string|null)>>;
-  }
-
-  /**
-   * Configures this account with the currently set parameters.
-   * Setup the credential config before calling this.
-   */
-  public configure(accountId: T.U32): Promise<null> {
-    return (this._transport.request('configure', [accountId] as RPC.Params)) as Promise<null>;
-  }
-
-  /**
-   * Signal an ongoing process to stop.
-   */
-  public stopOngoingProcess(accountId: T.U32): Promise<null> {
-    return (this._transport.request('stop_ongoing_process', [accountId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public autocryptInitiateKeyTransfer(accountId: T.U32): Promise<string> {
-    return (this._transport.request('autocrypt_initiate_key_transfer', [accountId] as RPC.Params)) as Promise<string>;
-  }
-
-
-  public autocryptContinueKeyTransfer(accountId: T.U32, messageId: T.U32, setupCode: string): Promise<null> {
-    return (this._transport.request('autocrypt_continue_key_transfer', [accountId, messageId, setupCode] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public getChatlistEntries(accountId: T.U32, listFlags: (T.U32|null), queryString: (string|null), queryContactId: (T.U32|null)): Promise<(T.ChatListEntry)[]> {
-    return (this._transport.request('get_chatlist_entries', [accountId, listFlags, queryString, queryContactId] as RPC.Params)) as Promise<(T.ChatListEntry)[]>;
-  }
-
-
-  public getChatlistItemsByEntries(accountId: T.U32, entries: (T.ChatListEntry)[]): Promise<Record<T.U32,T.ChatListItemFetchResult>> {
-    return (this._transport.request('get_chatlist_items_by_entries', [accountId, entries] as RPC.Params)) as Promise<Record<T.U32,T.ChatListItemFetchResult>>;
-  }
-
-
-  public chatlistGetFullChatById(accountId: T.U32, chatId: T.U32): Promise<T.FullChat> {
-    return (this._transport.request('chatlist_get_full_chat_by_id', [accountId, chatId] as RPC.Params)) as Promise<T.FullChat>;
-  }
-
-
-  public acceptChat(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('accept_chat', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public blockChat(accountId: T.U32, chatId: T.U32): Promise<null> {
-    return (this._transport.request('block_chat', [accountId, chatId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public messageListGetMessageIds(accountId: T.U32, chatId: T.U32, flags: T.U32): Promise<(T.U32)[]> {
-    return (this._transport.request('message_list_get_message_ids', [accountId, chatId, flags] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-
-  public messageGetMessage(accountId: T.U32, messageId: T.U32): Promise<T.Message> {
-    return (this._transport.request('message_get_message', [accountId, messageId] as RPC.Params)) as Promise<T.Message>;
-  }
-
-
-  public messageGetMessages(accountId: T.U32, messageIds: (T.U32)[]): Promise<Record<T.U32,T.Message>> {
-    return (this._transport.request('message_get_messages', [accountId, messageIds] as RPC.Params)) as Promise<Record<T.U32,T.Message>>;
-  }
-
-  /**
-   * Get a single contact options by ID.
-   */
-  public contactsGetContact(accountId: T.U32, contactId: T.U32): Promise<T.Contact> {
-    return (this._transport.request('contacts_get_contact', [accountId, contactId] as RPC.Params)) as Promise<T.Contact>;
-  }
-
-  /**
-   * Add a single contact as a result of an explicit user action.
-   *
-   * Returns contact id of the created or existing contact
-   */
-  public contactsCreateContact(accountId: T.U32, email: string, name: (string|null)): Promise<T.U32> {
-    return (this._transport.request('contacts_create_contact', [accountId, email, name] as RPC.Params)) as Promise<T.U32>;
-  }
-
-  /**
-   * Returns contact id of the created or existing DM chat with that contact
-   */
-  public contactsCreateChatByContactId(accountId: T.U32, contactId: T.U32): Promise<T.U32> {
-    return (this._transport.request('contacts_create_chat_by_contact_id', [accountId, contactId] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-  public contactsBlock(accountId: T.U32, contactId: T.U32): Promise<null> {
-    return (this._transport.request('contacts_block', [accountId, contactId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public contactsUnblock(accountId: T.U32, contactId: T.U32): Promise<null> {
-    return (this._transport.request('contacts_unblock', [accountId, contactId] as RPC.Params)) as Promise<null>;
-  }
-
-
-  public contactsGetBlocked(accountId: T.U32): Promise<(T.Contact)[]> {
-    return (this._transport.request('contacts_get_blocked', [accountId] as RPC.Params)) as Promise<(T.Contact)[]>;
-  }
-
-
-  public contactsGetContactIds(accountId: T.U32, listFlags: T.U32, query: (string|null)): Promise<(T.U32)[]> {
-    return (this._transport.request('contacts_get_contact_ids', [accountId, listFlags, query] as RPC.Params)) as Promise<(T.U32)[]>;
-  }
-
-  /**
-   * Get a list of contacts.
-   * (formerly called getContacts2 in desktop)
-   */
-  public contactsGetContacts(accountId: T.U32, listFlags: T.U32, query: (string|null)): Promise<(T.Contact)[]> {
-    return (this._transport.request('contacts_get_contacts', [accountId, listFlags, query] as RPC.Params)) as Promise<(T.Contact)[]>;
-  }
-
-
-  public contactsGetContactsByIds(accountId: T.U32, ids: (T.U32)[]): Promise<Record<T.U32,T.Contact>> {
-    return (this._transport.request('contacts_get_contacts_by_ids', [accountId, ids] as RPC.Params)) as Promise<Record<T.U32,T.Contact>>;
-  }
-
-  /**
-   * Returns the messageid of the sent message
-   */
-  public miscSendTextMessage(accountId: T.U32, text: string, chatId: T.U32): Promise<T.U32> {
-    return (this._transport.request('misc_send_text_message', [accountId, text, chatId] as RPC.Params)) as Promise<T.U32>;
-  }
-
-
-}

deltachat-jsonrpc/typescript/generated/events.ts

@@ -1,3 +0,0 @@
-// AUTO-GENERATED by typescript-type-def
-
-export type EventTypeName=("Info"|"SmtpConnected"|"ImapConnected"|"SmtpMessageSent"|"ImapMessageDeleted"|"ImapMessageMoved"|"NewBlobFile"|"DeletedBlobFile"|"Warning"|"Error"|"ErrorSelfNotInGroup"|"MsgsChanged"|"IncomingMsg"|"MsgsNoticed"|"MsgDelivered"|"MsgFailed"|"MsgRead"|"ChatModified"|"ChatEphemeralTimerModified"|"ContactsChanged"|"LocationChanged"|"ConfigureProgress"|"ImexProgress"|"ImexFileWritten"|"SecurejoinInviterProgress"|"SecurejoinJoinerProgress"|"ConnectivityChanged"|"SelfavatarChanged"|"WebxdcStatusUpdate");

deltachat-jsonrpc/typescript/generated/jsonrpc.ts

@@ -1,10 +0,0 @@
-// AUTO-GENERATED by typescript-type-def
-
-export type JSONValue=(null|boolean|number|string|(JSONValue)[]|{[key:string]:JSONValue;});
-export type Params=((JSONValue)[]|Record<string,JSONValue>);
-export type U32=number;
-export type Request={"jsonrpc":"2.0";"method":string;"params"?:Params;"id"?:U32;};
-export type I32=number;
-export type Error={"code":I32;"message":string;"data"?:JSONValue;};
-export type Response={"jsonrpc":"2.0";"id":(U32|null);"result"?:JSONValue;"error"?:Error;};
-export type Message=(Request|Response);

deltachat-jsonrpc/typescript/generated/types.ts

@@ -1,15 +0,0 @@
-// AUTO-GENERATED by typescript-type-def
-
-export type U32=number;
-export type Account=(({"type":"Configured";}&{"id":U32;"display_name":(string|null);"addr":(string|null);"profile_image":(string|null);"color":string;})|({"type":"Unconfigured";}&{"id":U32;}));
-export type ProviderInfo={"before_login_hint":string;"overview_page":string;"status":U32;};
-export type ChatListEntry=[U32,U32];
-export type I64=number;
-export type Usize=number;
-export type ChatListItemFetchResult=(({"type":"ChatListItem";}&{"id":U32;"name":string;"avatarPath":(string|null);"color":string;"lastUpdated":(I64|null);"summaryText1":string;"summaryText2":string;"summaryStatus":U32;"isProtected":boolean;"isGroup":boolean;"freshMessageCounter":Usize;"isSelfTalk":boolean;"isDeviceTalk":boolean;"isSendingLocation":boolean;"isSelfInGroup":boolean;"isArchived":boolean;"isPinned":boolean;"isMuted":boolean;"isContactRequest":boolean;})|{"type":"ArchiveLink";}|({"type":"Error";}&{"id":U32;"error":string;}));
-export type Contact={"address":string;"color":string;"auth_name":string;"status":string;"display_name":string;"id":U32;"name":string;"profile_image":(string|null);"name_and_addr":string;"is_blocked":boolean;"is_verified":boolean;};
-export type FullChat={"id":U32;"name":string;"is_protected":boolean;"profile_image":(string|null);"archived":boolean;"chat_type":U32;"is_unpromoted":boolean;"is_self_talk":boolean;"contacts":(Contact)[];"contact_ids":(U32)[];"color":string;"fresh_message_counter":Usize;"is_contact_request":boolean;"is_device_chat":boolean;"self_in_group":boolean;"is_muted":boolean;"ephemeral_timer":U32;"can_send":boolean;};
-export type I32=number;
-export type U64=number;
-export type Message={"id":U32;"chat_id":U32;"from_id":U32;"quoted_text":(string|null);"quoted_message_id":(U32|null);"text":(string|null);"has_location":boolean;"has_html":boolean;"view_type":U32;"state":U32;"timestamp":I64;"sort_timestamp":I64;"received_timestamp":I64;"has_deviating_timestamp":boolean;"subject":string;"show_padlock":boolean;"is_setupmessage":boolean;"is_info":boolean;"is_forwarded":boolean;"duration":I32;"dimensions_height":I32;"dimensions_width":I32;"videochat_type":(U32|null);"videochat_url":(string|null);"override_sender_name":(string|null);"sender":Contact;"setup_code_begin":(string|null);"file":(string|null);"file_mime":(string|null);"file_bytes":U64;"file_name":(string|null);};
-export type __AllTyps=[string,boolean,Record<string,string>,U32,U32,null,(U32)[],U32,null,(U32|null),(Account)[],U32,Account,U32,string,(ProviderInfo|null),U32,boolean,U32,Record<string,string>,U32,string,(string|null),null,U32,Record<string,(string|null)>,null,U32,string,(string|null),U32,(string)[],Record<string,(string|null)>,U32,null,U32,null,U32,string,U32,U32,string,null,U32,(U32|null),(string|null),(U32|null),(ChatListEntry)[],U32,(ChatListEntry)[],Record<U32,ChatListItemFetchResult>,U32,U32,FullChat,U32,U32,null,U32,U32,null,U32,U32,U32,(U32)[],U32,U32,Message,U32,(U32)[],Record<U32,Message>,U32,U32,Contact,U32,string,(string|null),U32,U32,U32,U32,U32,U32,null,U32,U32,null,U32,(Contact)[],U32,U32,(string|null),(U32)[],U32,U32,(string|null),(Contact)[],U32,(U32)[],Record<U32,Contact>,U32,string,U32,U32];

deltachat-jsonrpc/typescript/index.html

@@ -1,54 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <style>
-      body {
-        font-family: monospace;
-        background: black;
-        color: grey;
-      }
-      .grid {
-        display: grid;
-        grid-template-columns: 3fr 1fr;
-        grid-template-areas: "a a" "b c";
-      }
-      .message {
-        color: red;
-      }
-      #header {
-        grid-area: a;
-        color: white;
-        font-size: 1.2rem;
-      }
-      #header a {
-        color: white;
-        font-weight: bold;
-      }
-      #main {
-        grid-area: b;
-        color: green;
-      }
-      #main h2,
-      #main h3 {
-        color: blue;
-      }
-      #side {
-        grid-area: c;
-        color: #777;
-        overflow-y: auto;
-      }
-    </style>
-    <script type="module" src="dist/example.bundle.js"></script>
-  </head>
-  <body>
-    <div class="grid">
-      <div id="header"></div>
-      <div id="main"></div>
-      <div id="side"><h2>log</h2></div>
-    </div>
-    <p>
-      Tip: open the dev console and use the client with
-      <code>window.client</code>
-    </p>
-  </body>
-</html>

deltachat-jsonrpc/typescript/node-demo.js

@@ -1,13 +0,0 @@
-import { Deltachat } from "./dist/deltachat.js";
-
-run().catch(console.error);
-
-async function run() {
-  const delta = new Deltachat();
-  delta.addEventListener("event", (event) => {
-    console.log("event", event.data);
-  });
-
-  const accounts = await delta.rpc.getAllAccounts();
-  console.log("accounts", accounts);
-}

deltachat-jsonrpc/typescript/package.json

@@ -1,41 +0,0 @@
-{
-  "name": "@deltachat/jsonrpc-client",
-  "version": "0.1.0",
-  "main": "dist/deltachat.js",
-  "types": "dist/deltachat.d.ts",
-  "type": "module",
-  "author": "Delta Chat Developers (ML) <delta@codespeak.net>",
-  "license": "MPL-2.0",
-  "scripts": {
-    "prettier:check": "prettier --check **.ts",
-    "prettier:fix": "prettier --write **.ts",
-    "build": "npm run generate-bindings && tsc",
-    "bundle": "npm run build && esbuild --bundle dist/deltachat.js --outfile=dist/deltachat.bundle.js",
-    "generate-bindings": "cargo test",
-    "example:build": "tsc && esbuild --bundle dist/example.js --outfile=dist/example.bundle.js",
-    "example:dev": "esbuild example.ts --bundle --outdir=dist --servedir=.",
-    "coverage": "tsc -b test && COVERAGE=1 NODE_OPTIONS=--enable-source-maps c8 --include \"dist/*\" -r text -r html -r json mocha test_dist && node report_api_coverage.mjs",
-    "test": "rm -rf dist && npm run build && npm run coverage && npm run prettier:check"
-  },
-  "dependencies": {
-    "isomorphic-ws": "^4.0.1",
-    "tiny-emitter": "git+https://github.com/Simon-Laux/tiny-emitter.git",
-    "yerpc": "^0.2.3"
-  },
-  "devDependencies": {
-    "prettier": "^2.6.2",
-    "chai-as-promised": "^7.1.1",
-    "@types/chai": "^4.2.21",
-    "@types/chai-as-promised": "^7.1.5",
-    "@types/mocha": "^9.0.0",
-    "@types/node-fetch": "^2.5.7",
-    "@types/ws": "^7.2.4",
-    "c8": "^7.10.0",
-    "chai": "^4.3.4",
-    "esbuild": "^0.14.11",
-    "mocha": "^9.1.1",
-    "node-fetch": "^2.6.1",
-    "typescript": "^4.5.5",
-    "ws": "^8.5.0"
-  }
-}

deltachat-jsonrpc/typescript/report_api_coverage.mjs

@@ -1,28 +0,0 @@
-import { readFileSync } from "fs";
-// only checks for the coverge of the api functions in bindings.ts for now
-const generated_file = "typescript/generated/client.ts";
-const json = JSON.parse(readFileSync("./coverage/coverage-final.json"));
-const jsonCoverage =
-  json[Object.keys(json).find((k) => k.includes(generated_file))];
-const fnMap = Object.keys(jsonCoverage.fnMap).map(
-  (key) => jsonCoverage.fnMap[key]
-);
-const htmlCoverage = readFileSync(
-  "./coverage/" + generated_file + ".html",
-  "utf8"
-);
-const uncoveredLines = htmlCoverage
-  .split("\n")
-  .filter((line) => line.includes(`"function not covered"`));
-const uncoveredFunctions = uncoveredLines.map(
-  (line) => />([\w_]+)\(/.exec(line)[1]
-);
-console.log(
-  "\nUncovered api functions:\n" +
-    uncoveredFunctions
-      .map((uF) => fnMap.find(({ name }) => name === uF))
-      .map(
-        ({ name, line }) => `.${name.padEnd(40)}  (${generated_file}:${line})`
-      )
-      .join("\n")
-);

deltachat-jsonrpc/typescript/src/client.ts

@@ -1,77 +0,0 @@
-import * as T from "../generated/types.js";
-import * as RPC from "../generated/jsonrpc.js";
-import { RawClient } from "../generated/client.js";
-import { EventTypeName } from "../generated/events.js";
-import { WebsocketTransport, BaseTransport, Request } from "yerpc";
-import { TinyEmitter } from "tiny-emitter";
-
-export type DeltachatEvent = {
-  id: EventTypeName;
-  contextId: number;
-  field1: any;
-  field2: any;
-};
-export type Events = Record<
-  EventTypeName | "ALL",
-  (event: DeltachatEvent) => void
->;
-
-export class BaseDeltachat<
-  Transport extends BaseTransport
-> extends TinyEmitter<Events> {
-  rpc: RawClient;
-  account?: T.Account;
-  constructor(protected transport: Transport) {
-    super();
-    this.rpc = new RawClient(this.transport);
-    this.transport.on("request", (request: Request) => {
-      const method = request.method;
-      if (method === "event") {
-        const event = request.params! as DeltachatEvent;
-        this.emit(event.id, event);
-        this.emit("ALL", event);
-
-        if (this.contextEmitters[event.contextId]) {
-          this.contextEmitters[event.contextId].emit(event.id, event);
-          this.contextEmitters[event.contextId].emit("ALL", event);
-        }
-      }
-    });
-  }
-
-  async listAccounts(): Promise<T.Account[]> {
-    return await this.rpc.getAllAccounts();
-  }
-
-  private contextEmitters: TinyEmitter<Events>[] = [];
-
-  getContextEvents(account_id: number) {
-    if (this.contextEmitters[account_id]) {
-      return this.contextEmitters[account_id];
-    } else {
-      this.contextEmitters[account_id] = new TinyEmitter();
-      return this.contextEmitters[account_id];
-    }
-  }
-}
-
-export type Opts = {
-  url: string;
-};
-
-export const DEFAULT_OPTS: Opts = {
-  url: "ws://localhost:20808/ws",
-};
-export class Deltachat extends BaseDeltachat<WebsocketTransport> {
-  opts: Opts;
-  close() {
-    this.transport._socket.close();
-  }
-  constructor(opts: Opts | string | undefined) {
-    if (typeof opts === "string") opts = { url: opts };
-    if (opts) opts = { ...DEFAULT_OPTS, ...opts };
-    else opts = { ...DEFAULT_OPTS };
-    super(new WebsocketTransport(opts.url));
-    this.opts = opts;
-  }
-}

deltachat-jsonrpc/typescript/src/lib.ts

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

deltachat-jsonrpc/typescript/test/README.md

@@ -1 +0,0 @@
-# tests need to be ported to new API

deltachat-jsonrpc/typescript/test/basic.ts

@@ -1,158 +0,0 @@
-import { strictEqual } from "assert";
-import chai, { assert, expect } from "chai";
-import chaiAsPromised from "chai-as-promised";
-chai.use(chaiAsPromised);
-import { Deltachat } from "../dist/deltachat.js";
-
-import {
-  CMD_API_Server_Handle,
-  CMD_API_SERVER_PORT,
-  startCMD_API_Server,
-} from "./test_base.js";
-
-describe("basic tests", () => {
-  let server_handle: CMD_API_Server_Handle;
-  let dc: Deltachat;
-
-  before(async () => {
-    server_handle = await startCMD_API_Server(CMD_API_SERVER_PORT);
-    // make sure server is up by the time we continue
-    await new Promise((res) => setTimeout(res, 100));
-
-    dc = new Deltachat({
-      url: "ws://localhost:" + CMD_API_SERVER_PORT + "/ws",
-    });
-    dc.on("ALL", (event) => {
-      //console.log("event", event);
-    });
-  });
-
-  after(async () => {
-    dc && dc.close();
-    await server_handle.close();
-  });
-
-  it("check email", async () => {
-    const positive_test_cases = [
-      "email@example.com",
-      "36aa165ae3406424e0c61af17700f397cad3fe8ab83d682d0bddf3338a5dd52e@yggmail@yggmail",
-    ];
-    const negative_test_cases = ["email@", "example.com", "emai221"];
-
-    expect(
-      await Promise.all(
-        positive_test_cases.map((email) => dc.rpc.checkEmailValidity(email))
-      )
-    ).to.not.contain(false);
-
-    expect(
-      await Promise.all(
-        negative_test_cases.map((email) => dc.rpc.checkEmailValidity(email))
-      )
-    ).to.not.contain(true);
-  });
-
-  it("system info", async () => {
-    const system_info = await dc.rpc.getSystemInfo();
-    expect(system_info).to.contain.keys([
-      "arch",
-      "num_cpus",
-      "deltachat_core_version",
-      "sqlite_version",
-    ]);
-  });
-
-  describe("account managment", () => {
-    it("should create account", async () => {
-      await dc.rpc.addAccount();
-      assert((await dc.rpc.getAllAccountIds()).length === 1);
-    });
-
-    it("should remove the account again", async () => {
-      await dc.rpc.removeAccount((await dc.rpc.getAllAccountIds())[0]);
-      assert((await dc.rpc.getAllAccountIds()).length === 0);
-    });
-
-    it("should create multiple accounts", async () => {
-      await dc.rpc.addAccount();
-      await dc.rpc.addAccount();
-      await dc.rpc.addAccount();
-      await dc.rpc.addAccount();
-      assert((await dc.rpc.getAllAccountIds()).length === 4);
-    });
-  });
-
-  describe("contact managment", function () {
-    let acc: number;
-    before(async () => {
-      acc = await dc.rpc.addAccount();
-    });
-    it("block and unblock contact", async function () {
-      const contactId = await dc.rpc.contactsCreateContact(
-        acc,
-        "example@delta.chat",
-        null
-      );
-      expect((await dc.rpc.contactsGetContact(acc, contactId)).is_blocked).to.be
-        .false;
-      await dc.rpc.contactsBlock(acc, contactId);
-      expect((await dc.rpc.contactsGetContact(acc, contactId)).is_blocked).to.be
-        .true;
-      expect(await dc.rpc.contactsGetBlocked(acc)).to.have.length(1);
-      await dc.rpc.contactsUnblock(acc, contactId);
-      expect((await dc.rpc.contactsGetContact(acc, contactId)).is_blocked).to.be
-        .false;
-      expect(await dc.rpc.contactsGetBlocked(acc)).to.have.length(0);
-    });
-  });
-
-  describe("configuration", function () {
-    let acc: number;
-    before(async () => {
-      acc = await dc.rpc.addAccount();
-    });
-
-    it("set and retrive", async function () {
-      await dc.rpc.setConfig(acc, "addr", "valid@email");
-      assert((await dc.rpc.getConfig(acc, "addr")) == "valid@email");
-    });
-    it("set invalid key should throw", async function () {
-      await expect(dc.rpc.setConfig(acc, "invalid_key", "some value")).to.be
-        .eventually.rejected;
-    });
-    it("get invalid key should throw", async function () {
-      await expect(dc.rpc.getConfig(acc, "invalid_key")).to.be.eventually
-        .rejected;
-    });
-    it("set and retrive ui.*", async function () {
-      await dc.rpc.setConfig(acc, "ui.chat_bg", "color:red");
-      assert((await dc.rpc.getConfig(acc, "ui.chat_bg")) == "color:red");
-    });
-    it("set and retrive (batch)", async function () {
-      const config = { addr: "valid@email", mail_pw: "1234" };
-      await dc.rpc.batchSetConfig(acc, config);
-      const retrieved = await dc.rpc.batchGetConfig(acc, Object.keys(config));
-      expect(retrieved).to.deep.equal(config);
-    });
-    it("set and retrive ui.* (batch)", async function () {
-      const config = {
-        "ui.chat_bg": "color:green",
-        "ui.enter_key_sends": "true",
-      };
-      await dc.rpc.batchSetConfig(acc, config);
-      const retrieved = await dc.rpc.batchGetConfig(acc, Object.keys(config));
-      expect(retrieved).to.deep.equal(config);
-    });
-    it("set and retrive mixed(ui and core) (batch)", async function () {
-      const config = {
-        "ui.chat_bg": "color:yellow",
-        "ui.enter_key_sends": "false",
-        addr: "valid2@email",
-        mail_pw: "123456",
-      };
-      await dc.rpc.batchSetConfig(acc, config);
-      const retrieved = await dc.rpc.batchGetConfig(acc, Object.keys(config));
-      expect(retrieved).to.deep.equal(config);
-    });
-  });
-});

deltachat-jsonrpc/typescript/test/online.ts

@@ -1,203 +0,0 @@
-import { assert, expect } from "chai";
-import { Deltachat, DeltachatEvent, EventTypeName } from "../dist/deltachat.js";
-import {
-  CMD_API_Server_Handle,
-  CMD_API_SERVER_PORT,
-  createTempUser,
-  startCMD_API_Server,
-} from "./test_base.js";
-
-describe("online tests", function () {
-  let server_handle: CMD_API_Server_Handle;
-  let dc: Deltachat;
-  let account: { email: string; password: string };
-  let account2: { email: string; password: string };
-  let acc1: number, acc2: number;
-
-  before(async function () {
-    this.timeout(12000)
-    if (!process.env.DCC_NEW_TMP_EMAIL) {
-      if (process.env.COVERAGE && !process.env.COVERAGE_OFFLINE) {
-        console.error(
-          "CAN NOT RUN COVERAGE correctly: Missing DCC_NEW_TMP_EMAIL environment variable!\n\n",
-          "You can set COVERAGE_OFFLINE=1 to circumvent this check and skip the online tests, but those coverage results will be wrong, because some functions can only be tested in the online test"
-        );
-        process.exit(1);
-      }
-      console.log(
-        "Missing DCC_NEW_TMP_EMAIL environment variable!, skip intergration tests"
-      );
-      this.skip();
-    }
-    server_handle = await startCMD_API_Server(CMD_API_SERVER_PORT);
-    dc = new Deltachat({
-      url: "ws://localhost:" + CMD_API_SERVER_PORT + "/ws",
-    });
-
-    dc.on("ALL", ({ id, contextId }) => {
-      if (id !== "Info") console.log(contextId, id);
-    });
-
-    account = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
-    if (!account || !account.email || !account.password) {
-      console.log(
-        "We didn't got back an account from the api, skip intergration tests"
-      );
-      this.skip();
-    }
-
-    account2 = await createTempUser(process.env.DCC_NEW_TMP_EMAIL);
-    if (!account2 || !account2.email || !account2.password) {
-      console.log(
-        "We didn't got back an account2 from the api, skip intergration tests"
-      );
-      this.skip();
-    }
-  });
-
-  after(async () => {
-    dc && dc.close();
-    server_handle && (await server_handle.close());
-  });
-
-  let are_configured = false;
-
-  it("configure test accounts", async function () {
-    this.timeout(20000);
-
-    acc1 = await dc.rpc.addAccount();
-    await dc.rpc.setConfig(acc1, "addr", account.email);
-    await dc.rpc.setConfig(acc1, "mail_pw", account.password);
-    let configure_promise = dc.rpc.configure(acc1);
-
-    acc2 = await dc.rpc.addAccount();
-    await dc.rpc.batchSetConfig(acc2, {
-      addr: account2.email,
-      mail_pw: account2.password,
-    });
-
-    await Promise.all([configure_promise, dc.rpc.configure(acc2)]);
-    are_configured = true;
-  });
-
-  it("send and recieve text message", async function () {
-    if (!are_configured) {
-      this.skip();
-    }
-    this.timeout(15000);
-
-    const contactId = await dc.rpc.contactsCreateContact(
-      acc1,
-      account2.email,
-      null
-    );
-    const chatId = await dc.rpc.contactsCreateChatByContactId(acc1, contactId);
-    const eventPromise = Promise.race([
-      waitForEvent(dc, "MsgsChanged", acc2),
-      waitForEvent(dc, "IncomingMsg", acc2),
-    ]);
-
-    dc.rpc.miscSendTextMessage(acc1, "Hello", chatId);
-    const { field1: chatIdOnAccountB } = await eventPromise;
-    await dc.rpc.acceptChat(acc2, chatIdOnAccountB);
-    const messageList = await dc.rpc.messageListGetMessageIds(
-      acc2,
-      chatIdOnAccountB,
-      0
-    );
-
-    expect(messageList).have.length(1);
-    const message = await dc.rpc.messageGetMessage(acc2, messageList[0]);
-    expect(message.text).equal("Hello");
-  });
-
-  it("send and recieve text message roundtrip, encrypted on answer onwards", async function () {
-    if (!are_configured) {
-      this.skip();
-    }
-    this.timeout(10000);
-
-    // send message from A to B
-    const contactId = await dc.rpc.contactsCreateContact(
-      acc1,
-      account2.email,
-      null
-    );
-    const chatId = await dc.rpc.contactsCreateChatByContactId(acc1, contactId);
-    const eventPromise = Promise.race([
-      waitForEvent(dc, "MsgsChanged", acc2),
-      waitForEvent(dc, "IncomingMsg", acc2),
-    ]);
-    dc.rpc.miscSendTextMessage(acc1, "Hello2", chatId);
-    // wait for message from A
-    console.log("wait for message from A");
-
-    const event = await eventPromise;
-    const { field1: chatIdOnAccountB } = event;
-
-    await dc.rpc.acceptChat(acc2, chatIdOnAccountB);
-    const messageList = await dc.rpc.messageListGetMessageIds(
-      acc2,
-      chatIdOnAccountB,
-      0
-    );
-    const message = await dc.rpc.messageGetMessage(
-      acc2,
-      messageList.reverse()[0]
-    );
-    expect(message.text).equal("Hello2");
-    // Send message back from B to A
-    const eventPromise2 = Promise.race([
-      waitForEvent(dc, "MsgsChanged", acc1),
-      waitForEvent(dc, "IncomingMsg", acc1),
-    ]);
-    dc.rpc.miscSendTextMessage(acc2, "super secret message", chatId);
-    // Check if answer arives at A and if it is encrypted
-    await eventPromise2;
-
-    const messageId = (
-      await dc.rpc.messageListGetMessageIds(acc1, chatId, 0)
-    ).reverse()[0];
-    const message2 = await dc.rpc.messageGetMessage(acc1, messageId);
-    expect(message2.text).equal("super secret message");
-    expect(message2.show_padlock).equal(true);
-  });
-
-  it("get provider info for example.com", async () => {
-    const acc = await dc.rpc.addAccount();
-    const info = await dc.rpc.getProviderInfo(acc, "example.com");
-    expect(info).to.be.not.null;
-    expect(info?.overview_page).to.equal(
-      "https://providers.delta.chat/example-com"
-    );
-    expect(info?.status).to.equal(3);
-  });
-
-  it("get provider info - domain and email should give same result", async () => {
-    const acc = await dc.rpc.addAccount();
-    const info_domain = await dc.rpc.getProviderInfo(acc, "example.com");
-    const info_email = await dc.rpc.getProviderInfo(acc, "hi@example.com");
-    expect(info_email).to.deep.equal(info_domain);
-  });
-});
-
-type event_data = {
-  contextId: number;
-  id: EventTypeName;
-  [key: string]: any;
-};
-async function waitForEvent(
-  dc: Deltachat,
-  event: EventTypeName,
-  accountId: number
-): Promise<event_data> {
-  return new Promise((res, rej) => {
-    const callback = (ev: DeltachatEvent) => {
-      if (ev.contextId == accountId) {
-        dc.off(event, callback);
-        res(ev);
-      }
-    };
-    dc.on(event, callback);
-  });
-}

deltachat-jsonrpc/typescript/test/test_base.ts

@@ -1,95 +0,0 @@
-import { tmpdir } from "os";
-import { join } from "path";
-import { mkdtemp, rm } from "fs/promises";
-import { existsSync } from "fs";
-import { spawn, exec } from "child_process";
-import { unwrapPromise } from "./ts_helpers.js";
-import fetch from "node-fetch";
-/* port is not configurable yet */
-
-
-function getTargetDir(): Promise<string> {
-  return new Promise((res, rej) => {
-    exec(
-      "cargo metadata --no-deps --format-version 1",
-      (error, stdout, stderr) => {
-        if (error) {
-          console.log("error", error);
-          rej(error);
-        } else {
-          try {
-            const json = JSON.parse(stdout);
-            res(json.target_directory);
-          } catch (error) {
-            console.log("json error", error);
-            rej(error);
-          }
-        }
-      }
-    );
-  });
-}
-
-export const CMD_API_SERVER_PORT = 20808;
-export async function startCMD_API_Server(port: typeof CMD_API_SERVER_PORT) {
-  const tmp_dir = await mkdtemp(join(tmpdir(), "test_prefix"));
-
-  const path_of_server = join(await getTargetDir(), "debug/webserver");
-  console.log(path_of_server);
-
-  if (!existsSync(path_of_server)) {
-    throw new Error(
-      "server executable does not exist, you need to build it first" +
-        "\nserver executable not found at " +
-        path_of_server
-    );
-  }
-
-  const server = spawn(path_of_server, {
-    cwd: tmp_dir,
-    env: {
-      RUST_LOG: "info",
-    },
-  });
-  let should_close = false;
-
-  server.on("exit", () => {
-    if (should_close) {
-      return;
-    }
-    throw new Error("Server quit");
-  });
-
-  server.stderr.pipe(process.stderr);
-
-  //server.stdout.pipe(process.stdout)
-
-  return {
-    close: async () => {
-      should_close = true;
-      if (!server.kill(9)) {
-        console.log("server termination failed");
-      }
-      await rm(tmp_dir, { recursive: true });
-    },
-  };
-}
-
-export type CMD_API_Server_Handle = unwrapPromise<
-  ReturnType<typeof startCMD_API_Server>
->;
-
-export async function createTempUser(url: string) {
-  async function postData(url = "") {
-    // Default options are marked with *
-    const response = await fetch(url, {
-      method: "POST", // *GET, POST, PUT, DELETE, etc.
-      headers: {
-        "cache-control": "no-cache",
-      },
-    });
-    return response.json(); // parses JSON response into native JavaScript objects
-  }
-
-  return await postData(url);
-}

deltachat-jsonrpc/typescript/test/ts_helpers.ts

@@ -1 +0,0 @@
-export type unwrapPromise<T> = T extends Promise<infer U> ? U : never;

deltachat-jsonrpc/typescript/test/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": ".",
-    "outDir": "../test_dist",
-    "target": "ES2020",
-    "module": "es2020",
-    "moduleResolution": "node",
-    "declaration": false,
-    "esModuleInterop": true,
-    "noImplicitAny": true,
-    "isolatedModules": true,
-    "strictNullChecks": true,
-    "strict": true,
-    "sourceMap": true
-  },
-  "compileOnSave": true
-}

deltachat-jsonrpc/typescript/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "alwaysStrict": true,
-    "strict": true,
-    "sourceMap": true,
-    "strictNullChecks": true,
-    "rootDir": ".",
-    "outDir": "dist",
-    "lib": ["ES2017", "dom"],
-    "target": "ES2017",
-    "module": "es2015",
-    "declaration": true,
-    "esModuleInterop": true,
-    "moduleResolution": "node",
-    "noImplicitAny": true,
-    "isolatedModules": true
-  },
-  "include": ["*.ts"],
-  "compileOnSave": false
-}

draft/aeap-mvp.md

@@ -11,26 +11,49 @@ Changes to the UIs
 Changes in the core
 -------------------
 
-- DONE: We have one primary self address and any number of secondary self addresses. `is_self_addr()` checks all of them.
+- [x] We have one primary self address and any number of secondary self addresses. `is_self_addr()` checks all of them.
 
-- DONE: If the user does a reconfigure and changes the email address, the previous address is added as a secondary self address.
+- [x] If the user does a reconfigure and changes the email address, the previous address is added as a secondary self address.
 
   - don't forget to deduplicate secondary self addresses in case the user switches back and forth between addresses).
 
   - The key stays the same.
 
-- No changes for 1:1 chats, there simply is a new one. (This works since, contrary to group messages, messages sent to a 1:1 chat are not assigned to the group chat but always to the 1:1 chat with the sender. So it's not a problem that the new messages might be put into the old chat if they are a reply to a message there.)
+- [x] No changes for 1:1 chats, there simply is a new one. (This works since, contrary to group messages, messages sent to a 1:1 chat are not assigned to the group chat but always to the 1:1 chat with the sender. So it's not a problem that the new messages might be put into the old chat if they are a reply to a message there.)
 
-- When sending a message: If any of the secondary self addrs is in the chat's member list, remove it locally (because we just transitioned away from it). We add a log message for this (alternatively, a system message in the chat would be more visible).
+- [ ] When sending a message: If any of the secondary self addrs is in the chat's member list, remove it locally (because we just transitioned away from it). We add a log message for this (alternatively, a system message in the chat would be more visible).
 
-- When receiving a message: If the key exists, but belongs to another address (we may want to benchmark this)
+- [x] ([#3385](https://github.com/deltachat/deltachat-core-rust/pull/3385)) When receiving a message: If the key exists, but belongs to another address (we may want to benchmark this)
   AND there is a `Chat-Version` header\
+  AND the message is signed correctly
+  AND the From address is (also) in the encrypted (and therefore signed) headers <sup>[[1]](#myfootnote1)</sup>\
   AND the message timestamp is newer than the contact's `lastseen` (to prevent changing the address back when messages arrive out of order) (this condition is not that important since we will have eventual consistency even without it):
 
   Replace the contact in _all_ groups, possibly deduplicate the members list, and add a system message to all of these chats.
   
   - Note that we can't simply compare the keys byte-by-byte, since the UID may have changed, or the sender may have rotated the key and signed the new key with the old one.
 
+<a name="myfootnote1">[1]</a>: Without this check, an attacker could replay a message from Alice to Bob. Then Bob's device would do an AEAP transition from Alice's to the attacker's address, allowing for easier phishing.
+
+<details>
+<summary>More details about this</summary>
+Suppose Alice sends a message to Evil (or to a group with both Evil and Bob). Evil then forwards the message to Bob, changing the From and To headers (and if necessary Message-Id) and replacing `addr=alice@example.org;` in the autocrypt header with `addr=evil@example.org;`.
+
+Then Bob's device sees that there is a message which is signed by Alice's key and comes from Evil's address and would do the AEAP transition, i.e. replace Alice with Evil in all groups and show a message "Alice changed their address from alice@example.org to evil@example.org". Disadvantages for Evil are that Bob's message will be shown on Alice's device, possibly creating confusion/suspicion, and that the usual "Setup changed for..." message will be shown the next time Evil sends a message (because Evil doesn't know Alice's private key).
+
+Possible mitigations:
+- if we make the AEAP device message sth. like "Automatically removed alice@example.org and added evil@example.org", then this will create more suspicion, making the phishing harder (we didn't talk about what what the wording should be at all yet).
+- Add something similar to replay protection to our Autocrypt implementation. This could be done e.g. by adding a second `From` header to the protected headers. If it's present, the receiver then requires it to be the same as the outer `From`, and if it's not present, we don't do AEAP --> **That's what we implemented**
+
+Note that usually a mail is signed by a key that has a UID matching the from address.
+
+  That's not mandatory for Autocrypt (and in fact, we just keep the old UID when changing the self address, so with AEAP the UID will actually be different than the from address sometimes)
+
+  https://autocrypt.org/level1.html#openpgp-based-key-data says:
+  > The content of the user id packet is only decorative
+
+</details>
+
 ### Notes:
   
 - We treat protected and non-protected chats the same
@@ -97,3 +120,8 @@ Other
 -----
 
 - The user is responsible that messages to the old address arrive at the new address, for example by configuring the old provider to forward all emails to the new one.
+
+Notes during implementing
+========================
+
+- As far as I understand the code, unencrypted messages are unsigned. So, the transition only works if both sides have the other side's key.

examples/repl/cmdline.rs

@@ -1,9 +1,10 @@
 extern crate dirs;
 
+use std::path::Path;
 use std::str::FromStr;
+use std::time::{Duration, SystemTime};
 
 use anyhow::{bail, ensure, Result};
-use async_std::path::Path;
 use deltachat::chat::{
     self, Chat, ChatId, ChatItem, ChatVisibility, MuteDuration, ProtectionStatus,
 };
@@ -11,8 +12,6 @@ use deltachat::chatlist::*;
 use deltachat::constants::*;
 use deltachat::contact::*;
 use deltachat::context::*;
-use deltachat::dc_receive_imf::*;
-use deltachat::dc_tools::*;
 use deltachat::download::DownloadState;
 use deltachat::imex::*;
 use deltachat::location;
@@ -20,10 +19,11 @@ use deltachat::log::LogExt;
 use deltachat::message::{self, Message, MessageState, MsgId, Viewtype};
 use deltachat::peerstate::*;
 use deltachat::qr::*;
+use deltachat::receive_imf::*;
 use deltachat::sql;
+use deltachat::tools::*;
 use deltachat::{config, provider};
-use std::fs;
-use std::time::{Duration, SystemTime};
+use tokio::fs;
 
 /// Reset database tables.
 /// Argument is a bitmask, executing single or multiple actions in one call.
@@ -96,10 +96,10 @@ async fn reset_tables(context: &Context, bits: i32) {
 }
 
 async fn poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<()> {
-    let data = dc_read_file(context, filename).await?;
+    let data = read_file(context, filename).await?;
 
-    if let Err(err) = dc_receive_imf(context, &data, false).await {
-        println!("dc_receive_imf errored: {:?}", err);
+    if let Err(err) = receive_imf(context, &data, false).await {
+        println!("receive_imf errored: {:?}", err);
     }
     Ok(())
 }
@@ -128,24 +128,20 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
         }
         real_spec = rs.unwrap();
     }
-    if let Some(suffix) = dc_get_filesuffix_lc(&real_spec) {
+    if let Some(suffix) = get_filesuffix_lc(&real_spec) {
         if suffix == "eml" && poke_eml_file(context, &real_spec).await.is_ok() {
             read_cnt += 1
         }
     } else {
         /* import a directory */
         let dir_name = std::path::Path::new(&real_spec);
-        let dir = std::fs::read_dir(dir_name);
+        let dir = fs::read_dir(dir_name).await;
         if dir.is_err() {
             error!(context, "Import: Cannot open directory \"{}\".", &real_spec,);
             return false;
         } else {
-            let dir = dir.unwrap();
-            for entry in dir {
-                if entry.is_err() {
-                    break;
-                }
-                let entry = entry.unwrap();
+            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();
                 if name.ends_with(".eml") {
@@ -191,7 +187,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
         DownloadState::Failure => " [⬇ Download failed]",
     };
 
-    let temp2 = dc_timestamp_to_str(msg.get_timestamp());
+    let temp2 = timestamp_to_str(msg.get_timestamp());
     let msgtext = msg.get_text();
     println!(
         "{}{}{}{}: {} (Contact#{}): {} {}{}{}{}{}{}{} [{}]",
@@ -219,6 +215,14 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
                 msg.get_videochat_url().unwrap_or_default(),
                 msg.get_videochat_type().unwrap_or_default()
             )
+        } else if msg.get_viewtype() == Viewtype::Webxdc {
+            match msg.get_webxdc_info(context).await {
+                Ok(info) => format!(
+                    "[WEBXDC: {}, icon={}, document={}, summary={}, source_code_url={}]",
+                    info.name, info.icon, info.document, info.summary, info.source_code_url
+                ),
+                Err(err) => format!("[get_webxdc_info() failed: {}]", err),
+            }
         } else {
             "".to_string()
         },
@@ -492,7 +496,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let setup_code = create_setup_code(&context);
             let file_name = blobdir.join("autocrypt-setup-message.html");
             let file_content = render_setup_file(&context, &setup_code).await?;
-            async_std::fs::write(&file_name, file_content).await?;
+            fs::write(&file_name, file_content).await?;
             println!(
                 "Setup message written to: {}\nSetup code: {}",
                 file_name.display(),
@@ -532,7 +536,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 .join("connectivity.html");
             match context.get_connectivity_html().await {
                 Ok(html) => {
-                    fs::write(&file, html)?;
+                    fs::write(&file, html).await?;
                     println!("Report written to: {:#?}", file);
                 }
                 Err(err) => {
@@ -597,7 +601,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                             _ => "",
                         }
                     };
-                    let timestr = dc_timestamp_to_str(summary.timestamp);
+                    let timestr = timestamp_to_str(summary.timestamp);
                     println!(
                         "{}{}{} [{}]{}",
                         summary
@@ -810,7 +814,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 println!(
                     "Loc#{}: {}: lat={} lng={} acc={} Chat#{} Contact#{} {} {}",
                     location.location_id,
-                    dc_timestamp_to_str(location.timestamp),
+                    timestamp_to_str(location.timestamp),
                     location.latitude,
                     location.longitude,
                     location.accuracy,
@@ -892,7 +896,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             ensure!(sel_chat.is_some(), "No chat selected.");
             ensure!(!arg1.is_empty(), "No html-file given.");
             let path: &Path = arg1.as_ref();
-            let html = &*fs::read(&path)?;
+            let html = &*fs::read(&path).await?;
             let html = String::from_utf8_lossy(html);
 
             let mut msg = Message::new(Viewtype::Text);
@@ -1079,7 +1083,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 .unwrap_or_default()
                 .join(format!("msg-{}.html", id.to_u32()));
             let html = id.get_html(&context).await?.unwrap_or_default();
-            fs::write(&file, html)?;
+            fs::write(&file, html).await?;
             println!("HTML written to: {:#?}", file);
         }
         "listfresh" => {
@@ -1233,8 +1237,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         "fileinfo" => {
             ensure!(!arg1.is_empty(), "Argument <file> missing.");
 
-            if let Ok(buf) = dc_read_file(&context, &arg1).await {
-                let (width, height) = dc_get_filemeta(&buf)?;
+            if let Ok(buf) = read_file(&context, &arg1).await {
+                let (width, height) = get_filemeta(&buf)?;
                 println!("width={}, height={}", width, height);
             } else {
                 bail!("Command failed.");

examples/repl/main.rs

@@ -9,15 +9,16 @@ extern crate deltachat;
 
 use std::borrow::Cow::{self, Borrowed, Owned};
 use std::io::{self, Write};
+use std::path::Path;
 use std::process::Command;
 
 use ansi_term::Color;
 use anyhow::{bail, Error};
-use async_std::path::Path;
 use deltachat::chat::ChatId;
 use deltachat::config;
 use deltachat::context::*;
 use deltachat::oauth2::*;
+use deltachat::qr_code_generator::get_securejoin_qr_svg;
 use deltachat::securejoin::*;
 use deltachat::{EventType, Events};
 use log::{error, info, warn};
@@ -30,11 +31,11 @@ use rustyline::validate::Validator;
 use rustyline::{
     Cmd, CompletionType, Config, Context as RustyContext, EditMode, Editor, Helper, KeyEvent,
 };
+use tokio::fs;
+use tokio::runtime::Handle;
 
 mod cmdline;
 use self::cmdline::*;
-use deltachat::qr_code_generator::get_securejoin_qr_svg;
-use std::fs;
 
 /// Event Handler
 fn receive_event(event: EventType) {
@@ -298,10 +299,10 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
         println!("Error: Bad arguments, expected [db-name].");
         bail!("No db-name specified");
     }
-    let context = Context::new(Path::new(&args[1]).to_path_buf(), 0, Events::new()).await?;
+    let context = Context::new(Path::new(&args[1]), 0, Events::new()).await?;
 
     let events = context.get_event_emitter();
-    async_std::task::spawn(async move {
+    tokio::task::spawn(async move {
         while let Some(event) = events.recv().await {
             receive_event(event.typ);
         }
@@ -316,8 +317,9 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
         .output_stream(OutputStreamType::Stdout)
         .build();
     let mut selected_chat = ChatId::default();
-    let (reader_s, reader_r) = async_std::channel::bounded(100);
-    let input_loop = async_std::task::spawn_blocking(move || {
+
+    let ctx = context.clone();
+    let input_loop = tokio::task::spawn_blocking(move || {
         let h = DcHelper {
             completer: FilenameCompleter::new(),
             highlighter: MatchingBracketHighlighter::new(),
@@ -339,16 +341,30 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
                 Ok(line) => {
                     // TODO: ignore "set mail_pw"
                     rl.add_history_entry(line.as_str());
-                    async_std::task::block_on(reader_s.send(line)).unwrap();
+                    let contine = Handle::current().block_on(async {
+                        match handle_cmd(line.trim(), ctx.clone(), &mut selected_chat).await {
+                            Ok(ExitResult::Continue) => true,
+                            Ok(ExitResult::Exit) => {
+                                println!("Exiting ...");
+                                false
+                            }
+                            Err(err) => {
+                                println!("Error: {}", err);
+                                true
+                            }
+                        }
+                    });
+
+                    if !contine {
+                        break;
+                    }
                 }
                 Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => {
                     println!("Exiting...");
-                    drop(reader_s);
                     break;
                 }
                 Err(err) => {
                     println!("Error: {}", err);
-                    drop(reader_s);
                     break;
                 }
             }
@@ -359,15 +375,8 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
         Ok::<_, Error>(())
     });
 
-    while let Ok(line) = reader_r.recv().await {
-        match handle_cmd(line.trim(), context.clone(), &mut selected_chat).await {
-            Ok(ExitResult::Continue) => {}
-            Ok(ExitResult::Exit) => break,
-            Err(err) => println!("Error: {}", err),
-        }
-    }
     context.stop_io().await;
-    input_loop.await?;
+    input_loop.await??;
 
     Ok(())
 }
@@ -400,7 +409,7 @@ async fn handle_cmd(
         "oauth2" => {
             if let Some(addr) = ctx.get_config(config::Config::Addr).await? {
                 let oauth2_url =
-                    dc_get_oauth2_url(&ctx, &addr, "chat.delta:/com.b44t.messenger").await?;
+                    get_oauth2_url(&ctx, &addr, "chat.delta:/com.b44t.messenger").await?;
                 if oauth2_url.is_none() {
                     println!("OAuth2 not available for {}.", &addr);
                 } else {
@@ -417,7 +426,7 @@ async fn handle_cmd(
         "getqr" | "getbadqr" => {
             ctx.start_io().await;
             let group = arg1.parse::<u32>().ok().map(ChatId::new);
-            let mut qr = dc_get_securejoin_qr(&ctx, group).await?;
+            let mut qr = get_securejoin_qr(&ctx, group).await?;
             if !qr.is_empty() {
                 if arg0 == "getbadqr" && qr.len() > 40 {
                     qr.replace_range(12..22, "0000000000")
@@ -437,7 +446,7 @@ async fn handle_cmd(
             let file = dirs::home_dir().unwrap_or_default().join("qr.svg");
             match get_securejoin_qr_svg(&ctx, group).await {
                 Ok(svg) => {
-                    fs::write(&file, svg)?;
+                    fs::write(&file, svg).await?;
                     println!("QR code svg written to: {:#?}", file);
                 }
                 Err(err) => {
@@ -448,7 +457,7 @@ async fn handle_cmd(
         "joinqr" => {
             ctx.start_io().await;
             if !arg0.is_empty() {
-                dc_join_securejoin(&ctx, arg1).await?;
+                join_securejoin(&ctx, arg1).await?;
             }
         }
         "exit" | "quit" => return Ok(ExitResult::Exit),
@@ -458,11 +467,12 @@ async fn handle_cmd(
     Ok(ExitResult::Continue)
 }
 
-fn main() -> Result<(), Error> {
+#[tokio::main]
+async fn main() -> Result<(), Error> {
     let _ = pretty_env_logger::try_init();
 
     let args = std::env::args().collect();
-    async_std::task::block_on(async move { start(args).await })?;
+    start(args).await?;
 
     Ok(())
 }

examples/simple.rs

@@ -29,21 +29,21 @@ fn cb(event: EventType) {
 }
 
 /// Run with `RUST_LOG=simple=info cargo run --release --example simple --features repl -- email pw`.
-#[async_std::main]
+#[tokio::main]
 async fn main() {
     pretty_env_logger::try_init_timed().ok();
 
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
     log::info!("creating database {:?}", dbfile);
-    let ctx = Context::new(dbfile.into(), 0, Events::new())
+    let ctx = Context::new(&dbfile, 0, Events::new())
         .await
         .expect("Failed to create context");
     let info = ctx.get_info().await;
     log::info!("info: {:#?}", info);
 
     let events = ctx.get_event_emitter();
-    let events_spawn = async_std::task::spawn(async move {
+    let events_spawn = tokio::task::spawn(async move {
         while let Some(event) = events.recv().await {
             cb(event.typ);
         }
@@ -80,7 +80,7 @@ async fn main() {
     }
 
     // wait for the message to be sent out
-    async_std::task::sleep(std::time::Duration::from_secs(1)).await;
+    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
 
     log::info!("fetching chats..");
     let chats = Chatlist::try_load(&ctx, 0, None, None).await.unwrap();
@@ -96,5 +96,5 @@ async fn main() {
     ctx.stop_io().await;
     log::info!("closing");
     drop(ctx);
-    events_spawn.await;
+    events_spawn.await.unwrap();
 }

node/README.md

@@ -117,7 +117,7 @@ $ fnm install 17 --arch x64
 $ fnm use 17
 $ node -p process.arch
 # result should be x64
-$ cd deltachat-core-rust && rustup target add x86_64-apple-darwin && cd -
+$ rustup target add x86_64-apple-darwin
 $ git apply patches/m1_build_use_x86_64.patch
 $ CARGO_BUILD_TARGET=x86_64-apple-darwin npm run build
 $ npm run test

node/lib/deltachat.ts

@@ -19,11 +19,10 @@ interface NativeAccount {}
 export class AccountManager extends EventEmitter {
   dcn_accounts: NativeAccount
   accountDir: string
-  jsonRpcStarted = false
 
   constructor(cwd: string, os = 'deltachat-node') {
-    super()
     debug('DeltaChat constructor')
+    super()
 
     this.accountDir = cwd
     this.dcn_accounts = binding.dcn_accounts_new(os, this.accountDir)
@@ -115,31 +114,6 @@ export class AccountManager extends EventEmitter {
     debug('Started event handler')
   }
 
-  startJSONRPCHandler(callback: ((response: string) => void) | null) {
-    if (this.dcn_accounts === null) {
-      throw new Error('dcn_account is null')
-    }
-    if (!callback) {
-      throw new Error('no callback set')
-    }
-    if (this.jsonRpcStarted) {
-      throw new Error('jsonrpc was started already')
-    }
-
-    binding.dcn_accounts_start_jsonrpc(this.dcn_accounts, callback.bind(this))
-    debug('Started jsonrpc handler')
-    this.jsonRpcStarted = true
-  }
-
-  jsonRPCRequest(message: string) {
-    if (!this.jsonRpcStarted) {
-      throw new Error(
-        'jsonrpc is not active, start it with startJSONRPCHandler first'
-      )
-    }
-    binding.dcn_json_rpc_request(this.dcn_accounts, message)
-  }
-
   startIO() {
     binding.dcn_accounts_start_io(this.dcn_accounts)
   }

node/scripts/rebuild-core.js

@@ -9,7 +9,7 @@ const buildArgs = [
   'build',
   '--release',
   '--features',
-  'vendored,jsonrpc',
+  'vendored',
   '-p',
   'deltachat_ffi'
 ]

node/src/module.c

@@ -34,9 +34,6 @@ typedef struct dcn_accounts_t {
   dc_accounts_t* dc_accounts;
   napi_threadsafe_function threadsafe_event_handler;
   uv_thread_t event_handler_thread;
-  napi_threadsafe_function threadsafe_jsonrpc_handler;
-  uv_thread_t jsonrpc_thread;
-  dc_jsonrpc_instance_t* jsonrpc_instance;
   int gc;
 } dcn_accounts_t;
 
@@ -101,14 +98,6 @@ static void finalize_provider(napi_env env, void* data, void* hint) {
   }
 }
 
-static void finalize_account(napi_env env, void* data, void* hint) {
-  if (data) {
-    dc_accounts_t* dcn_accounts = (dc_accounts_t*)data;
-    //TRACE("cleaning up provider");
-    dc_accounts_unref(dcn_accounts);
-  }
-}
-
 /**
  * Helpers.
  */
@@ -2935,11 +2924,6 @@ NAPI_METHOD(dcn_accounts_unref) {
     uv_thread_join(&dcn_accounts->event_handler_thread);
     dcn_accounts->event_handler_thread = 0;
   }
-  if (dcn_accounts->jsonrpc_instance) {
-    dc_jsonrpc_request(dcn_accounts->jsonrpc_instance, "{}");
-    uv_thread_join(&dcn_accounts->jsonrpc_thread);
-    dcn_accounts->jsonrpc_instance = NULL;
-  }
   dc_accounts_unref(dcn_accounts->dc_accounts);
   dcn_accounts->dc_accounts = NULL;
 
@@ -3098,6 +3082,8 @@ static void accounts_event_handler_thread_func(void* arg)
 {
   dcn_accounts_t* dcn_accounts = (dcn_accounts_t*)arg;
 
+
+
   TRACE("event_handler_thread_func starting");
 
   dc_accounts_event_emitter_t * dc_accounts_event_emitter = dc_accounts_get_event_emitter(dcn_accounts->dc_accounts);
@@ -3248,125 +3234,6 @@ NAPI_METHOD(dcn_accounts_start_event_handler) {
   NAPI_RETURN_UNDEFINED();
 }
 
-// JSON RPC
-
-static void accounts_jsonrpc_thread_func(void* arg)
-{
-  dcn_accounts_t* dcn_accounts = (dcn_accounts_t*)arg;
-  TRACE("accounts_jsonrpc_thread_func starting");
-  char* response;
-  while (true) {
-    response = dc_jsonrpc_next_response(dcn_accounts->jsonrpc_instance);
-    if (response == NULL) {
-      // done or broken
-      break;
-    }
-
-    if (!dcn_accounts->threadsafe_jsonrpc_handler) {
-      TRACE("threadsafe_jsonrpc_handler not set, bailing");
-      break;
-    }
-    // Don't process events if we're being garbage collected!
-    if (dcn_accounts->gc == 1) {
-      TRACE("dc_accounts has been destroyed, bailing");
-      break;
-    }
-
-    napi_status status = napi_call_threadsafe_function(dcn_accounts->threadsafe_jsonrpc_handler, response, napi_tsfn_blocking);
-
-    if (status == napi_closing) {
-      TRACE("JS function got released, bailing");
-      break;
-    }
-  }
-  dc_jsonrpc_unref(dcn_accounts->jsonrpc_instance);
-  dcn_accounts->jsonrpc_instance = NULL;
-  TRACE("accounts_jsonrpc_thread_func ended");
-  napi_release_threadsafe_function(dcn_accounts->threadsafe_jsonrpc_handler, napi_tsfn_release);
-}
-
-static void call_accounts_js_jsonrpc_handler(napi_env env, napi_value js_callback, void* _context, void* data)
-{
-  char* response = (char*)data;
-  napi_value global;
-  napi_status status = napi_get_global(env, &global);
-  if (status != napi_ok) {
-    napi_throw_error(env, NULL, "Unable to get global");
-  }
-
-  napi_value argv[1];
-  if (response != 0) {
-    status = napi_create_string_utf8(env, response, NAPI_AUTO_LENGTH, &argv[0]);
-  } else {
-    status = napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &argv[0]);
-  }
-  if (status != napi_ok) {
-    napi_throw_error(env, NULL, "Unable to create argv for js jsonrpc_handler arguments");
-  } 
-  free(response);
-
-  TRACE("calling back into js");
-  napi_value result;
-  status = napi_call_function(
-    env,
-    global,
-    js_callback,
-    1,
-    argv,
-    &result);
-  if (status != napi_ok) {
-    TRACE("Unable to call jsonrpc_handler callback2");
-    const napi_extended_error_info* error_result;
-    NAPI_STATUS_THROWS(napi_get_last_error_info(env, &error_result));
-  }
-}
-
-NAPI_METHOD(dcn_accounts_start_jsonrpc) {
-  NAPI_ARGV(2);
-  NAPI_DCN_ACCOUNTS();
-  napi_value callback = argv[1];
-
-  TRACE("calling..");
-  napi_value async_resource_name;
-  NAPI_STATUS_THROWS(napi_create_string_utf8(env, "dc_accounts_jsonrpc_callback", NAPI_AUTO_LENGTH, &async_resource_name));
-
-  TRACE("creating threadsafe function..");
-
-  NAPI_STATUS_THROWS(napi_create_threadsafe_function(
-    env,
-    callback,
-    0,
-    async_resource_name,
-    1,
-    1,
-    NULL,
-    NULL,
-    dcn_accounts,
-    call_accounts_js_jsonrpc_handler,
-    &dcn_accounts->threadsafe_jsonrpc_handler));
-  TRACE("done");
-
-  dcn_accounts->gc = 0;
-  dcn_accounts->jsonrpc_instance = dc_jsonrpc_init(dcn_accounts->dc_accounts);
-
-  TRACE("creating uv thread..");
-  uv_thread_create(&dcn_accounts->jsonrpc_thread, accounts_jsonrpc_thread_func, dcn_accounts);
-
-  NAPI_RETURN_UNDEFINED();
-}
-
-NAPI_METHOD(dcn_json_rpc_request) {
-  NAPI_ARGV(2);
-  NAPI_DCN_ACCOUNTS();
-  if (!dcn_accounts->jsonrpc_instance) {
-    const char* msg = "dcn_accounts->jsonrpc_instance is null, have you called dcn_accounts_start_jsonrpc()?";
-    NAPI_STATUS_THROWS(napi_throw_type_error(env, NULL, msg));
-  }
-  NAPI_ARGV_UTF8_MALLOC(request, 1);
-  dc_jsonrpc_request(dcn_accounts->jsonrpc_instance, request);
-  free(request);
-}
-
 
 NAPI_INIT() {
   /**
@@ -3637,9 +3504,4 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(dcn_send_webxdc_status_update);
   NAPI_EXPORT_FUNCTION(dcn_get_webxdc_status_updates);
   NAPI_EXPORT_FUNCTION(dcn_msg_get_webxdc_blob);
-
-
-  /** jsonrpc **/
-  NAPI_EXPORT_FUNCTION(dcn_accounts_start_jsonrpc);
-  NAPI_EXPORT_FUNCTION(dcn_json_rpc_request);
 }

node/src/napi-macros-extensions.h

@@ -23,7 +23,7 @@
   dcn_accounts_t* dcn_accounts; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&dcn_accounts)); \
   if (!dcn_accounts) { \
-    const char* msg = "Provided dcn_acounts is null"; \
+    const char* msg = "Provided dnc_acounts is null"; \
     NAPI_STATUS_THROWS(napi_throw_type_error(env, NULL, msg)); \
   } \
   if (!dcn_accounts->dc_accounts) { \

node/test/test.js

@@ -2,7 +2,7 @@
 import DeltaChat, { Message } from '../dist'
 import binding from '../binding'
 
-import { deepEqual, deepStrictEqual, strictEqual } from 'assert'
+import { strictEqual } from 'assert'
 import chai, { expect } from 'chai'
 import chaiAsPromised from 'chai-as-promised'
 import { EventId2EventName, C } from '../dist/constants'
@@ -84,95 +84,6 @@ describe('static tests', function () {
   })
 })
 
-describe('JSON RPC', function () {
-  it('smoketest', async function () {
-    const { dc } = DeltaChat.newTemporary()
-    let promise_resolve
-    const promise = new Promise((res, _rej) => {
-      promise_resolve = res
-    })
-    dc.startJSONRPCHandler(promise_resolve)
-    dc.jsonRPCRequest(
-      JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'get_all_account_ids',
-        params: [],
-        id: 2,
-      })
-    )
-    deepStrictEqual(
-      {
-        jsonrpc: '2.0',
-        id: 2,
-        result: [1],
-      },
-      JSON.parse(await promise)
-    )
-    dc.close()
-  })
-
-  it('basic test', async function () {
-    const { dc } = DeltaChat.newTemporary()
-
-    const promises = {}
-    dc.startJSONRPCHandler((msg) => {
-      const response = JSON.parse(msg)
-      promises[response.id](response)
-      delete promises[response.id]
-    })
-    const call = (request) => {
-      dc.jsonRPCRequest(JSON.stringify(request))
-      return new Promise((res, _rej) => {
-        promises[request.id] = res
-      })
-    }
-
-    deepStrictEqual(
-      {
-        jsonrpc: '2.0',
-        id: 2,
-        result: [1],
-      },
-      await call({
-        jsonrpc: '2.0',
-        method: 'get_all_account_ids',
-        params: [],
-        id: 2,
-      })
-    )
-
-    deepStrictEqual(
-      {
-        jsonrpc: '2.0',
-        id: 3,
-        result: 2,
-      },
-      await call({
-        jsonrpc: '2.0',
-        method: 'add_account',
-        params: [],
-        id: 3,
-      })
-    )
-
-    deepStrictEqual(
-      {
-        jsonrpc: '2.0',
-        id: 4,
-        result: [1, 2],
-      },
-      await call({
-        jsonrpc: '2.0',
-        method: 'get_all_account_ids',
-        params: [],
-        id: 4,
-      })
-    )
-
-    dc.close()
-  })
-})
-
 describe('Basic offline Tests', function () {
   it('opens a context', async function () {
     const { dc, context } = DeltaChat.newTemporary()

package.json

@@ -1,6 +1,5 @@
 {
   "dependencies": {
-    "@deltachat/jsonrpc-client": "file:deltachat-jsonrpc/typescript",
     "debug": "^4.1.1",
     "napi-macros": "^2.0.0",
     "node-gyp-build": "^4.1.0"
@@ -61,5 +60,5 @@
     "test:mocha": "mocha -r esm node/test/test.js --growl --reporter=spec --bail"
   },
   "types": "node/dist/index.d.ts",
-  "version": "1.86.0"
-}
+  "version": "1.88.0"
+}

scripts/concourse/docs_wheels.yml

@@ -84,8 +84,9 @@ jobs:
         - name: coredeps-image
           path: image
       params:
-        CONTEXT: deltachat-core-rust/scripts/docker-coredeps
+        CONTEXT: deltachat-core-rust/scripts/coredeps
         UNPACK_ROOTFS: "true"
+        BUILD_ARG_BASEIMAGE: quay.io/pypa/manylinux2014_x86_64
       platform: linux
       caches:
       - path: cache
@@ -183,8 +184,9 @@ jobs:
         - name: coredeps-image
           path: image
       params:
-        CONTEXT: deltachat-core-rust/scripts/docker-coredeps-arm64
+        CONTEXT: deltachat-core-rust/scripts/coredeps
         UNPACK_ROOTFS: "true"
+        BUILD_ARG_BASEIMAGE: quay.io/pypa/manylinux2014_aarch64
       platform: linux
       caches:
       - path: cache
@@ -230,3 +232,73 @@ jobs:
           devpi use https://m.devpi.net/dc/master
           devpi login ((devpi.login)) --password ((devpi.password))
           devpi upload py-wheels/*manylinux201*
+
+- name: python-musl-x86_64
+  plan:
+  - get: deltachat-core-rust
+  - get: deltachat-core-rust-release
+    trigger: true
+
+  # Build manylinux image with additional dependencies
+  - task: build-coredeps
+    privileged: true
+    config:
+      inputs:
+        # Building the latest, not tagged coredeps
+        - name: deltachat-core-rust
+      image_resource:
+        source:
+          repository: concourse/oci-build-task
+        type: registry-image
+      outputs:
+        - name: coredeps-image
+          path: image
+      params:
+        CONTEXT: deltachat-core-rust/scripts/coredeps
+        UNPACK_ROOTFS: "true"
+        BUILD_ARG_BASEIMAGE: quay.io/pypa/musllinux_1_1_x86_64
+      platform: linux
+      caches:
+      - path: cache
+      run:
+        path: build
+
+  # Use built image to build python wheels
+  - task: build-wheels
+    image: coredeps-image
+    config:
+      inputs:
+        - name: deltachat-core-rust-release
+          path: .
+      outputs:
+        - name: py-wheels
+          path: ./python/.docker-tox/wheelhouse/
+      platform: linux
+      run:
+        path: bash
+        args:
+        - -exc
+        - |
+          scripts/run_all.sh
+
+  # Upload musl x86_64 wheels
+  - task: upload-wheels
+    config:
+      inputs:
+        - name: py-wheels
+      image_resource:
+        type: registry-image
+        source:
+          repository: debian
+      platform: linux
+      run:
+        path: sh
+        args:
+        - -ec
+        - |
+          apt-get update -y
+          apt-get install -y --no-install-recommends python3-pip python3-setuptools
+          pip3 install devpi
+          devpi use https://m.devpi.net/dc/master
+          devpi login ((devpi.login)) --password ((devpi.password))
+          devpi upload py-wheels/*musllinux_1_1_x86_64*

scripts/coredeps/Dockerfile

@@ -0,0 +1,8 @@
+ARG BASEIMAGE=quay.io/pypa/manylinux2014_x86_64
+#ARG BASEIMAGE=quay.io/pypa/musllinux_1_1_x86_64
+#ARG BASEIMAGE=quay.io/pypa/manylinux2014_aarch64
+
+FROM $BASEIMAGE
+RUN pipx install tox
+COPY install-rust.sh /scripts/
+RUN /scripts/install-rust.sh

scripts/coredeps/install-rust.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Install Rust
+#
+# Path from https://forge.rust-lang.org/infra/other-installation-methods.html
+#
+# Avoid using rustup here as it depends on reading /proc/self/exe and
+# has problems running under QEMU.
+RUST_VERSION=1.61.0
+
+ARCH="$(uname -m)"
+test -f "/lib/libc.musl-$ARCH.so.1" && LIBC=musl || LIBC=gnu
+
+curl "https://static.rust-lang.org/dist/rust-${RUST_VERSION}-$ARCH-unknown-linux-$LIBC.tar.gz" | tar xz
+cd "rust-${RUST_VERSION}-$ARCH-unknown-linux-$LIBC"
+./install.sh --prefix=/usr --components=rustc,cargo,"rust-std-$ARCH-unknown-linux-$LIBC"
+rustc --version
+cd ..
+rm -fr "rust-${RUST_VERSION}-$ARCH-unknown-linux-$LIBC"

scripts/docker-coredeps-arm64/Dockerfile

@@ -1,6 +0,0 @@
-FROM quay.io/pypa/manylinux2014_aarch64
-RUN pipx install tox
-
-# Install Rust
-ADD deps/build_rust.sh /builder/build_rust.sh
-RUN mkdir tmp1 && cd tmp1 && bash /builder/build_rust.sh && cd .. && rm -r tmp1

scripts/docker-coredeps-arm64/deps/build_rust.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-set -e -x
-
-# Install Rust
-#
-# Path from https://forge.rust-lang.org/infra/other-installation-methods.html
-#
-# Avoid using rustup here as it depends on reading /proc/self/exe and
-# has problems running under QEMU.
-RUST_VERSION=1.61.0
-
-curl "https://static.rust-lang.org/dist/rust-${RUST_VERSION}-$(uname -m)-unknown-linux-gnu.tar.gz" | tar xz
-cd "rust-${RUST_VERSION}-$(uname -m)-unknown-linux-gnu"
-./install.sh --prefix=/usr --components=rustc,cargo,"rust-std-$(uname -m)-unknown-linux-gnu"
-rustc --version
-cd ..
-rm -fr "rust-${RUST_VERSION}-$(uname -m)-unknown-linux-gnu"

scripts/docker-coredeps/Dockerfile

@@ -1,6 +0,0 @@
-FROM quay.io/pypa/manylinux2014_x86_64
-RUN pipx install tox
-
-# Install Rust
-ADD deps/build_rust.sh /builder/build_rust.sh
-RUN mkdir tmp1 && cd tmp1 && bash /builder/build_rust.sh && cd .. && rm -r tmp1

scripts/docker-coredeps/deps/build_rust.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-set -e -x
-
-# Install Rust
-#
-# Path from https://forge.rust-lang.org/infra/other-installation-methods.html
-#
-# Avoid using rustup here as it depends on reading /proc/self/exe and
-# has problems running under QEMU.
-RUST_VERSION=1.61.0
-
-curl "https://static.rust-lang.org/dist/rust-${RUST_VERSION}-$(uname -m)-unknown-linux-gnu.tar.gz" | tar xz
-cd "rust-${RUST_VERSION}-$(uname -m)-unknown-linux-gnu"
-./install.sh --prefix=/usr --components=rustc,cargo,"rust-std-$(uname -m)-unknown-linux-gnu"
-rustc --version
-cd ..
-rm -fr "rust-${RUST_VERSION}-$(uname -m)-unknown-linux-gnu"

scripts/run_all.sh

@@ -33,7 +33,7 @@ mkdir -p $TOXWORKDIR
 # Note that the independent remote_tests_python step does all kinds of
 # live-testing already. 
 unset DCC_NEW_TMP_EMAIL
-tox --workdir "$TOXWORKDIR" -e py37,py38,py39,py310,auditwheels
+tox --workdir "$TOXWORKDIR" -e py37,py38,py39,py310,pypy37,pypy38,pypy39,auditwheels
 popd
 
 

scripts/set_core_version.py

@@ -63,7 +63,7 @@ def main():
     parser = ArgumentParser(prog="set_core_version")
     parser.add_argument("newversion")
 
-    toml_list = ["Cargo.toml", "deltachat-ffi/Cargo.toml",  "deltachat-jsonrpc/Cargo.toml"]
+    toml_list = ["Cargo.toml", "deltachat-ffi/Cargo.toml"]
     try:
         opts = parser.parse_args()
     except SystemExit:

spec.md

@@ -1,6 +1,6 @@
 # chat-mail specification
 
-Version: 0.33.0
+Version: 0.34.0
 Status:  In-progress 
 Format:  [Semantic Line Breaks](https://sembr.org/)
 
@@ -474,4 +474,20 @@ as the sending time of the message as indicated by its Date header,
 or the time of first receipt if that date is in the future or unavailable.
 
 
+# Transitioning to a new e-mail address (AEAP)
+
+When receiving a message:
+- If the key exists, but belongs to another address
+- AND there is a `Chat-Version` header
+- AND the message is signed correctly
+- AND the From address is (also) in the encrypted (and therefore signed) headers 
+- AND the message timestamp is newer than the contact's `lastseen`
+  (to prevent changing the address back when messages arrive out of order)
+  (this condition is not that important
+  since we will have eventual consistency even without it):
+
+  Replace the contact in _all_ groups,
+  possibly deduplicate the members list,
+  and add a system message to all of these chats.
+
 Copyright © 2017-2021 Delta Chat contributors.

src/accounts.rs

@@ -1,13 +1,12 @@
 //! # Account manager module.
 
 use std::collections::BTreeMap;
-
-use async_std::fs;
-use async_std::path::PathBuf;
-use uuid::Uuid;
+use std::path::{Path, PathBuf};
 
 use anyhow::{ensure, Context as _, Result};
 use serde::{Deserialize, Serialize};
+use tokio::fs;
+use uuid::Uuid;
 
 use crate::context::Context;
 use crate::events::{Event, EventEmitter, EventType, Events};
@@ -26,7 +25,7 @@ pub struct Accounts {
 impl Accounts {
     /// Loads or creates an accounts folder at the given `dir`.
     pub async fn new(dir: PathBuf) -> Result<Self> {
-        if !dir.exists().await {
+        if !dir.exists() {
             Accounts::create(&dir).await?;
         }
 
@@ -47,14 +46,10 @@ impl Accounts {
     /// Opens an existing accounts structure. Will error if the folder doesn't exist,
     /// no account exists and no config exists.
     pub async fn open(dir: PathBuf) -> Result<Self> {
-        ensure!(dir.exists().await, "directory does not exist");
+        ensure!(dir.exists(), "directory does not exist");
 
         let config_file = dir.join(CONFIG_NAME);
-        ensure!(
-            config_file.exists().await,
-            "{:?} does not exist",
-            config_file
-        );
+        ensure!(config_file.exists(), "{:?} does not exist", config_file);
 
         let config = Config::from_file(config_file)
             .await
@@ -106,7 +101,7 @@ impl Accounts {
         let account_config = self.config.new_account(&self.dir).await?;
 
         let ctx = Context::new(
-            account_config.dbfile().into(),
+            &account_config.dbfile(),
             account_config.id,
             self.events.clone(),
         )
@@ -121,7 +116,7 @@ impl Accounts {
         let account_config = self.config.new_account(&self.dir).await?;
 
         let ctx = Context::new_closed(
-            account_config.dbfile().into(),
+            &account_config.dbfile(),
             account_config.id,
             self.events.clone(),
         )
@@ -148,7 +143,7 @@ impl Accounts {
             loop {
                 counter += 1;
 
-                if let Err(err) = fs::remove_dir_all(async_std::path::PathBuf::from(&cfg.dir))
+                if let Err(err) = fs::remove_dir_all(&cfg.dir)
                     .await
                     .context("failed to remove account data")
                 {
@@ -157,7 +152,7 @@ impl Accounts {
                     }
 
                     // Wait 1 second and try again.
-                    async_std::task::sleep(std::time::Duration::from_millis(1000)).await;
+                    tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
                 } else {
                     break;
                 }
@@ -173,16 +168,8 @@ impl Accounts {
         let blobdir = Context::derive_blobdir(&dbfile);
         let walfile = Context::derive_walfile(&dbfile);
 
-        ensure!(
-            dbfile.exists().await,
-            "no database found: {}",
-            dbfile.display()
-        );
-        ensure!(
-            blobdir.exists().await,
-            "no blobdir found: {}",
-            blobdir.display()
-        );
+        ensure!(dbfile.exists(), "no database found: {}", dbfile.display());
+        ensure!(blobdir.exists(), "no blobdir found: {}", blobdir.display());
 
         let old_id = self.config.get_selected_account().await;
 
@@ -193,7 +180,7 @@ impl Accounts {
             .await
             .context("failed to create new account")?;
 
-        let new_dbfile = account_config.dbfile().into();
+        let new_dbfile = account_config.dbfile();
         let new_blobdir = Context::derive_blobdir(&new_dbfile);
         let new_walfile = Context::derive_walfile(&new_dbfile);
 
@@ -207,7 +194,7 @@ impl Accounts {
             fs::rename(&blobdir, &new_blobdir)
                 .await
                 .context("failed to rename blobdir")?;
-            if walfile.exists().await {
+            if walfile.exists() {
                 fs::rename(&walfile, &new_walfile)
                     .await
                     .context("failed to rename walfile")?;
@@ -217,13 +204,13 @@ impl Accounts {
 
         match res {
             Ok(_) => {
-                let ctx = Context::new(new_dbfile, account_config.id, self.events.clone()).await?;
+                let ctx = Context::new(&new_dbfile, account_config.id, self.events.clone()).await?;
                 self.accounts.insert(account_config.id, ctx);
                 Ok(account_config.id)
             }
             Err(err) => {
                 // remove temp account
-                fs::remove_dir_all(async_std::path::PathBuf::from(&account_config.dir))
+                fs::remove_dir_all(std::path::PathBuf::from(&account_config.dir))
                     .await
                     .context("failed to remove account data")?;
 
@@ -321,7 +308,7 @@ struct InnerConfig {
 }
 
 impl Config {
-    pub async fn new(dir: &PathBuf) -> Result<Self> {
+    pub async fn new(dir: &Path) -> Result<Self> {
         let inner = InnerConfig {
             accounts: Vec::new(),
             selected_account: 0,
@@ -355,18 +342,14 @@ impl Config {
     pub async fn load_accounts(&self, events: &Events) -> Result<BTreeMap<u32, Context>> {
         let mut accounts = BTreeMap::new();
         for account_config in &self.inner.accounts {
-            let ctx = Context::new(
-                account_config.dbfile().into(),
-                account_config.id,
-                events.clone(),
-            )
-            .await
-            .with_context(|| {
-                format!(
-                    "failed to create context from file {:?}",
-                    account_config.dbfile()
-                )
-            })?;
+            let ctx = Context::new(&account_config.dbfile(), account_config.id, events.clone())
+                .await
+                .with_context(|| {
+                    format!(
+                        "failed to create context from file {:?}",
+                        account_config.dbfile()
+                    )
+                })?;
 
             accounts.insert(account_config.id, ctx);
         }
@@ -375,7 +358,7 @@ impl Config {
     }
 
     /// Create a new account in the given root directory.
-    async fn new_account(&mut self, dir: &PathBuf) -> Result<AccountConfig> {
+    async fn new_account(&mut self, dir: &Path) -> Result<AccountConfig> {
         let id = {
             let id = self.inner.next_id;
             let uuid = Uuid::new_v4();
@@ -383,7 +366,7 @@ impl Config {
 
             self.inner.accounts.push(AccountConfig {
                 id,
-                dir: target_dir.into(),
+                dir: target_dir,
                 uuid,
             });
             self.inner.next_id += 1;
@@ -464,10 +447,10 @@ impl AccountConfig {
 mod tests {
     use super::*;
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_account_new_open() {
         let dir = tempfile::tempdir().unwrap();
-        let p: PathBuf = dir.path().join("accounts1").into();
+        let p: PathBuf = dir.path().join("accounts1");
 
         let mut accounts1 = Accounts::new(p.clone()).await.unwrap();
         accounts1.add_account().await.unwrap();
@@ -482,10 +465,10 @@ mod tests {
         assert_eq!(accounts1.accounts.len(), accounts2.accounts.len());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_account_new_add_remove() {
         let dir = tempfile::tempdir().unwrap();
-        let p: PathBuf = dir.path().join("accounts").into();
+        let p: PathBuf = dir.path().join("accounts");
 
         let mut accounts = Accounts::new(p.clone()).await.unwrap();
         assert_eq!(accounts.accounts.len(), 0);
@@ -509,10 +492,10 @@ mod tests {
         assert_eq!(accounts.accounts.len(), 1);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_accounts_remove_last() -> Result<()> {
         let dir = tempfile::tempdir()?;
-        let p: PathBuf = dir.path().join("accounts").into();
+        let p: PathBuf = dir.path().join("accounts");
 
         let mut accounts = Accounts::new(p.clone()).await?;
         assert!(accounts.get_selected_account().await.is_none());
@@ -530,17 +513,17 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_migrate_account() {
         let dir = tempfile::tempdir().unwrap();
-        let p: PathBuf = dir.path().join("accounts").into();
+        let p: PathBuf = dir.path().join("accounts");
 
         let mut accounts = Accounts::new(p.clone()).await.unwrap();
         assert_eq!(accounts.accounts.len(), 0);
         assert_eq!(accounts.config.get_selected_account().await, 0);
 
-        let extern_dbfile: PathBuf = dir.path().join("other").into();
-        let ctx = Context::new(extern_dbfile.clone(), 0, Events::new())
+        let extern_dbfile: PathBuf = dir.path().join("other");
+        let ctx = Context::new(&extern_dbfile, 0, Events::new())
             .await
             .unwrap();
         ctx.set_config(crate::config::Config::Addr, Some("me@mail.com"))
@@ -567,10 +550,10 @@ mod tests {
     }
 
     /// Tests that accounts are sorted by ID.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_accounts_sorted() {
         let dir = tempfile::tempdir().unwrap();
-        let p: PathBuf = dir.path().join("accounts").into();
+        let p: PathBuf = dir.path().join("accounts");
 
         let mut accounts = Accounts::new(p.clone()).await.unwrap();
 
@@ -585,10 +568,10 @@ mod tests {
         }
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_accounts_ids_unique_increasing_and_persisted() -> Result<()> {
         let dir = tempfile::tempdir()?;
-        let p: PathBuf = dir.path().join("accounts").into();
+        let p: PathBuf = dir.path().join("accounts");
         let dummy_accounts = 10;
 
         let (id0, id1, id2) = {
@@ -667,10 +650,10 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_no_accounts_event_emitter() -> Result<()> {
         let dir = tempfile::tempdir().unwrap();
-        let p: PathBuf = dir.path().join("accounts").into();
+        let p: PathBuf = dir.path().join("accounts");
 
         let accounts = Accounts::new(p.clone()).await?;
 
@@ -682,7 +665,7 @@ mod tests {
 
         // Test that event emitter does not return `None` immediately.
         let duration = std::time::Duration::from_millis(1);
-        assert!(async_std::future::timeout(duration, event_emitter.recv())
+        assert!(tokio::time::timeout(duration, event_emitter.recv())
             .await
             .is_err());
 
@@ -693,10 +676,10 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_encrypted_account() -> Result<()> {
         let dir = tempfile::tempdir().context("failed to create tempdir")?;
-        let p: PathBuf = dir.path().join("accounts").into();
+        let p: PathBuf = dir.path().join("accounts");
 
         let mut accounts = Accounts::new(p.clone())
             .await

src/blob.rs

@@ -4,14 +4,13 @@ use core::cmp::max;
 use std::ffi::OsStr;
 use std::fmt;
 use std::io::Cursor;
-
-use async_std::path::{Path, PathBuf};
-use async_std::prelude::*;
-use async_std::{fs, io};
+use std::path::{Path, PathBuf};
 
 use anyhow::{format_err, Context as _, Error, Result};
 use image::{DynamicImage, ImageFormat};
 use num_traits::FromPrimitive;
+use tokio::io::AsyncWriteExt;
+use tokio::{fs, io};
 
 use crate::config::Config;
 use crate::constants::{
@@ -89,7 +88,7 @@ impl<'a> BlobObject<'a> {
                 Err(err) => {
                     if attempt >= MAX_ATTEMPT {
                         return Err(err).context("failed to create file");
-                    } else if attempt == 1 && !dir.exists().await {
+                    } else if attempt == 1 && !dir.exists() {
                         fs::create_dir_all(dir).await.ok_or_log(context);
                     } else {
                         name = format!("{}-{}{}", stem, rand::random::<u32>(), ext);
@@ -371,108 +370,81 @@ impl<'a> BlobObject<'a> {
         mut img_wh: u32,
         max_bytes: Option<usize>,
     ) -> Result<Option<String>> {
-        let mut img = image::open(&blob_abs).context("image recode failure")?;
-        let orientation = self.get_exif_orientation(context);
-        let mut encoded = Vec::new();
-        let mut changed_name = None;
+        tokio::task::block_in_place(move || {
+            let mut img = image::open(&blob_abs).context("image recode failure")?;
+            let orientation = self.get_exif_orientation(context);
+            let mut encoded = Vec::new();
+            let mut changed_name = None;
 
-        fn encode_img(img: &DynamicImage, encoded: &mut Vec<u8>) -> anyhow::Result<()> {
-            encoded.clear();
-            let mut buf = Cursor::new(encoded);
-            img.write_to(&mut buf, image::ImageFormat::Jpeg)?;
-            Ok(())
-        }
-        fn encoded_img_exceeds_bytes(
-            context: &Context,
-            img: &DynamicImage,
-            max_bytes: Option<usize>,
-            encoded: &mut Vec<u8>,
-        ) -> anyhow::Result<bool> {
-            if let Some(max_bytes) = max_bytes {
-                encode_img(img, encoded)?;
-                if encoded.len() > max_bytes {
-                    info!(
-                        context,
-                        "image size {}B ({}x{}px) exceeds {}B, need to scale down",
-                        encoded.len(),
-                        img.width(),
-                        img.height(),
-                        max_bytes,
-                    );
-                    return Ok(true);
-                }
-            }
-            Ok(false)
-        }
-        let exceeds_width = img.width() > img_wh || img.height() > img_wh;
+            let exceeds_width = img.width() > img_wh || img.height() > img_wh;
 
-        let do_scale =
-            exceeds_width || encoded_img_exceeds_bytes(context, &img, max_bytes, &mut encoded)?;
-        let do_rotate = matches!(orientation, Ok(90) | Ok(180) | Ok(270));
+            let do_scale =
+                exceeds_width || encoded_img_exceeds_bytes(context, &img, max_bytes, &mut encoded)?;
+            let do_rotate = matches!(orientation, Ok(90) | Ok(180) | Ok(270));
 
-        if do_scale || do_rotate {
-            if do_rotate {
-                img = match orientation {
-                    Ok(90) => img.rotate90(),
-                    Ok(180) => img.rotate180(),
-                    Ok(270) => img.rotate270(),
-                    _ => img,
-                }
-            }
-
-            if do_scale {
-                if !exceeds_width {
-                    // The image is already smaller than img_wh, but exceeds max_bytes
-                    // We can directly start with trying to scale down to 2/3 of its current width
-                    img_wh = max(img.width(), img.height()) * 2 / 3
-                }
-
-                loop {
-                    let new_img = img.thumbnail(img_wh, img_wh);
-
-                    if encoded_img_exceeds_bytes(context, &new_img, max_bytes, &mut encoded)? {
-                        if img_wh < 20 {
-                            return Err(format_err!(
-                                "Failed to scale image to below {}B",
-                                max_bytes.unwrap_or_default()
-                            ));
-                        }
-
-                        img_wh = img_wh * 2 / 3;
-                    } else {
-                        if encoded.is_empty() {
-                            encode_img(&new_img, &mut encoded)?;
-                        }
-
-                        info!(
-                            context,
-                            "Final scaled-down image size: {}B ({}px)",
-                            encoded.len(),
-                            img_wh
-                        );
-                        break;
+            if do_scale || do_rotate {
+                if do_rotate {
+                    img = match orientation {
+                        Ok(90) => img.rotate90(),
+                        Ok(180) => img.rotate180(),
+                        Ok(270) => img.rotate270(),
+                        _ => img,
                     }
                 }
+
+                if do_scale {
+                    if !exceeds_width {
+                        // The image is already smaller than img_wh, but exceeds max_bytes
+                        // We can directly start with trying to scale down to 2/3 of its current width
+                        img_wh = max(img.width(), img.height()) * 2 / 3
+                    }
+
+                    loop {
+                        let new_img = img.thumbnail(img_wh, img_wh);
+
+                        if encoded_img_exceeds_bytes(context, &new_img, max_bytes, &mut encoded)? {
+                            if img_wh < 20 {
+                                return Err(format_err!(
+                                    "Failed to scale image to below {}B",
+                                    max_bytes.unwrap_or_default()
+                                ));
+                            }
+
+                            img_wh = img_wh * 2 / 3;
+                        } else {
+                            if encoded.is_empty() {
+                                encode_img(&new_img, &mut encoded)?;
+                            }
+
+                            info!(
+                                context,
+                                "Final scaled-down image size: {}B ({}px)",
+                                encoded.len(),
+                                img_wh
+                            );
+                            break;
+                        }
+                    }
+                }
+
+                // The file format is JPEG now, we may have to change the file extension
+                if !matches!(ImageFormat::from_path(&blob_abs), Ok(ImageFormat::Jpeg)) {
+                    blob_abs = blob_abs.with_extension("jpg");
+                    let file_name = blob_abs.file_name().context("No avatar file name (???)")?;
+                    let file_name = file_name.to_str().context("Filename is no UTF-8 (???)")?;
+                    changed_name = Some(format!("$BLOBDIR/{}", file_name));
+                }
+
+                if encoded.is_empty() {
+                    encode_img(&img, &mut encoded)?;
+                }
+
+                std::fs::write(&blob_abs, &encoded)
+                    .context("failed to write recoded blob to file")?;
             }
 
-            // The file format is JPEG now, we may have to change the file extension
-            if !matches!(ImageFormat::from_path(&blob_abs), Ok(ImageFormat::Jpeg)) {
-                blob_abs = blob_abs.with_extension("jpg");
-                let file_name = blob_abs.file_name().context("No avatar file name (???)")?;
-                let file_name = file_name.to_str().context("Filename is no UTF-8 (???)")?;
-                changed_name = Some(format!("$BLOBDIR/{}", file_name));
-            }
-
-            if encoded.is_empty() {
-                encode_img(&img, &mut encoded)?;
-            }
-
-            fs::write(&blob_abs, &encoded)
-                .await
-                .context("failed to write recoded blob to file")?;
-        }
-
-        Ok(changed_name)
+            Ok(changed_name)
+        })
     }
 
     pub fn get_exif_orientation(&self, context: &Context) -> Result<i32, Error> {
@@ -500,6 +472,35 @@ impl<'a> fmt::Display for BlobObject<'a> {
     }
 }
 
+fn encode_img(img: &DynamicImage, encoded: &mut Vec<u8>) -> anyhow::Result<()> {
+    encoded.clear();
+    let mut buf = Cursor::new(encoded);
+    img.write_to(&mut buf, image::ImageFormat::Jpeg)?;
+    Ok(())
+}
+fn encoded_img_exceeds_bytes(
+    context: &Context,
+    img: &DynamicImage,
+    max_bytes: Option<usize>,
+    encoded: &mut Vec<u8>,
+) -> anyhow::Result<bool> {
+    if let Some(max_bytes) = max_bytes {
+        encode_img(img, encoded)?;
+        if encoded.len() > max_bytes {
+            info!(
+                context,
+                "image size {}B ({}x{}px) exceeds {}B, need to scale down",
+                encoded.len(),
+                img.width(),
+                img.height(),
+                max_bytes,
+            );
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
 #[cfg(test)]
 mod tests {
     use fs::File;
@@ -513,7 +514,16 @@ mod tests {
 
     use super::*;
 
-    #[async_std::test]
+    fn check_image_size(path: impl AsRef<Path>, width: u32, height: u32) -> image::DynamicImage {
+        tokio::task::block_in_place(move || {
+            let img = image::open(path).expect("failed to open image");
+            assert_eq!(img.width(), width, "invalid width");
+            assert_eq!(img.height(), height, "invalid height");
+            img
+        })
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create() {
         let t = TestContext::new().await;
         let blob = BlobObject::create(&t, "foo", b"hello").await.unwrap();
@@ -524,28 +534,28 @@ mod tests {
         assert_eq!(blob.to_abs_path(), t.get_blobdir().join("foo"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_lowercase_ext() {
         let t = TestContext::new().await;
         let blob = BlobObject::create(&t, "foo.TXT", b"hello").await.unwrap();
         assert_eq!(blob.as_name(), "$BLOBDIR/foo.txt");
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_as_file_name() {
         let t = TestContext::new().await;
         let blob = BlobObject::create(&t, "foo.txt", b"hello").await.unwrap();
         assert_eq!(blob.as_file_name(), "foo.txt");
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_as_rel_path() {
         let t = TestContext::new().await;
         let blob = BlobObject::create(&t, "foo.txt", b"hello").await.unwrap();
         assert_eq!(blob.as_rel_path(), Path::new("foo.txt"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_suffix() {
         let t = TestContext::new().await;
         let blob = BlobObject::create(&t, "foo.txt", b"hello").await.unwrap();
@@ -554,16 +564,16 @@ mod tests {
         assert_eq!(blob.suffix(), None);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_dup() {
         let t = TestContext::new().await;
         BlobObject::create(&t, "foo.txt", b"hello").await.unwrap();
         let foo_path = t.get_blobdir().join("foo.txt");
-        assert!(foo_path.exists().await);
+        assert!(foo_path.exists());
         BlobObject::create(&t, "foo.txt", b"world").await.unwrap();
         let mut dir = fs::read_dir(t.get_blobdir()).await.unwrap();
-        while let Some(dirent) = dir.next().await {
-            let fname = dirent.unwrap().file_name();
+        while let Ok(Some(dirent)) = dir.next_entry().await {
+            let fname = dirent.file_name();
             if fname == foo_path.file_name().unwrap() {
                 assert_eq!(fs::read(&foo_path).await.unwrap(), b"hello");
             } else {
@@ -574,20 +584,20 @@ mod tests {
         }
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_double_ext_preserved() {
         let t = TestContext::new().await;
         BlobObject::create(&t, "foo.tar.gz", b"hello")
             .await
             .unwrap();
         let foo_path = t.get_blobdir().join("foo.tar.gz");
-        assert!(foo_path.exists().await);
+        assert!(foo_path.exists());
         BlobObject::create(&t, "foo.tar.gz", b"world")
             .await
             .unwrap();
         let mut dir = fs::read_dir(t.get_blobdir()).await.unwrap();
-        while let Some(dirent) = dir.next().await {
-            let fname = dirent.unwrap().file_name();
+        while let Ok(Some(dirent)) = dir.next_entry().await {
+            let fname = dirent.file_name();
             if fname == foo_path.file_name().unwrap() {
                 assert_eq!(fs::read(&foo_path).await.unwrap(), b"hello");
             } else {
@@ -599,7 +609,7 @@ mod tests {
         }
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_long_names() {
         let t = TestContext::new().await;
         let s = "1".repeat(150);
@@ -608,7 +618,7 @@ mod tests {
         assert!(blobname.len() < 128);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_and_copy() {
         let t = TestContext::new().await;
         let src = t.dir.path().join("src");
@@ -623,10 +633,10 @@ mod tests {
             .await
             .is_err());
         let whoops = t.get_blobdir().join("whoops");
-        assert!(!whoops.exists().await);
+        assert!(!whoops.exists());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_from_path() {
         let t = TestContext::new().await;
 
@@ -646,7 +656,7 @@ mod tests {
         let data = fs::read(blob.to_abs_path()).await.unwrap();
         assert_eq!(data, b"boo");
     }
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_from_name_long() {
         let t = TestContext::new().await;
         let src_ext = t.dir.path().join("autocrypt-setup-message-4137848473.html");
@@ -709,34 +719,24 @@ mod tests {
         assert!(!stem.contains('?'));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_selfavatar_outside_blobdir() {
         let t = TestContext::new().await;
         let avatar_src = t.dir.path().join("avatar.jpg");
         let avatar_bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
-        File::create(&avatar_src)
-            .await
-            .unwrap()
-            .write_all(avatar_bytes)
-            .await
-            .unwrap();
+        fs::write(&avatar_src, avatar_bytes).await.unwrap();
         let avatar_blob = t.get_blobdir().join("avatar.jpg");
-        assert!(!avatar_blob.exists().await);
+        assert!(!avatar_blob.exists());
         t.set_config(Config::Selfavatar, Some(avatar_src.to_str().unwrap()))
             .await
             .unwrap();
-        assert!(avatar_blob.exists().await);
-        assert!(std::fs::metadata(&avatar_blob).unwrap().len() < avatar_bytes.len() as u64);
+        assert!(avatar_blob.exists());
+        assert!(fs::metadata(&avatar_blob).await.unwrap().len() < avatar_bytes.len() as u64);
         let avatar_cfg = t.get_config(Config::Selfavatar).await.unwrap();
         assert_eq!(avatar_cfg, avatar_blob.to_str().map(|s| s.to_string()));
 
-        let img = image::open(avatar_src).unwrap();
-        assert_eq!(img.width(), 1000);
-        assert_eq!(img.height(), 1000);
-
-        let img = image::open(&avatar_blob).unwrap();
-        assert_eq!(img.width(), BALANCED_AVATAR_SIZE);
-        assert_eq!(img.height(), BALANCED_AVATAR_SIZE);
+        check_image_size(avatar_src, 1000, 1000);
+        check_image_size(&avatar_blob, BALANCED_AVATAR_SIZE, BALANCED_AVATAR_SIZE);
 
         async fn file_size(path_buf: &PathBuf) -> u64 {
             let file = File::open(path_buf).await.unwrap();
@@ -750,25 +750,22 @@ mod tests {
             .unwrap();
         assert!(file_size(&avatar_blob).await <= 3000);
         assert!(file_size(&avatar_blob).await > 2000);
-        let img = image::open(&avatar_blob).unwrap();
-        assert!(img.width() > 130);
-        assert_eq!(img.width(), img.height());
+        tokio::task::block_in_place(move || {
+            let img = image::open(&avatar_blob).unwrap();
+            assert!(img.width() > 130);
+            assert_eq!(img.width(), img.height());
+        });
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_selfavatar_in_blobdir() {
         let t = TestContext::new().await;
         let avatar_src = t.get_blobdir().join("avatar.png");
-        File::create(&avatar_src)
-            .await
-            .unwrap()
-            .write_all(test_utils::AVATAR_900x900_BYTES)
+        fs::write(&avatar_src, test_utils::AVATAR_900x900_BYTES)
             .await
             .unwrap();
 
-        let img = image::open(&avatar_src).unwrap();
-        assert_eq!(img.width(), 900);
-        assert_eq!(img.height(), 900);
+        check_image_size(&avatar_src, 900, 900);
 
         t.set_config(Config::Selfavatar, Some(avatar_src.to_str().unwrap()))
             .await
@@ -779,37 +776,30 @@ mod tests {
             avatar_src.with_extension("jpg").to_str().unwrap()
         );
 
-        let img = image::open(avatar_cfg).unwrap();
-        assert_eq!(img.width(), BALANCED_AVATAR_SIZE);
-        assert_eq!(img.height(), BALANCED_AVATAR_SIZE);
+        check_image_size(avatar_cfg, BALANCED_AVATAR_SIZE, BALANCED_AVATAR_SIZE);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_selfavatar_copy_without_recode() {
         let t = TestContext::new().await;
         let avatar_src = t.dir.path().join("avatar.png");
         let avatar_bytes = include_bytes!("../test-data/image/avatar64x64.png");
-        File::create(&avatar_src)
-            .await
-            .unwrap()
-            .write_all(avatar_bytes)
-            .await
-            .unwrap();
+        fs::write(&avatar_src, avatar_bytes).await.unwrap();
         let avatar_blob = t.get_blobdir().join("avatar.png");
-        assert!(!avatar_blob.exists().await);
+        assert!(!avatar_blob.exists());
         t.set_config(Config::Selfavatar, Some(avatar_src.to_str().unwrap()))
             .await
             .unwrap();
-        assert!(avatar_blob.exists().await);
+        assert!(avatar_blob.exists());
         assert_eq!(
-            std::fs::metadata(&avatar_blob).unwrap().len(),
+            fs::metadata(&avatar_blob).await.unwrap().len(),
             avatar_bytes.len() as u64
         );
         let avatar_cfg = t.get_config(Config::Selfavatar).await.unwrap();
         assert_eq!(avatar_cfg, avatar_blob.to_str().map(|s| s.to_string()));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_recode_image_1() {
         let bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
         // BALANCED_IMAGE_SIZE > 1000, the original image size, so the image is not scaled down:
@@ -829,7 +819,7 @@ mod tests {
         .unwrap();
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_recode_image_2() {
         // The "-rotated" files are rotated by 270 degrees using the Exif metadata
         let bytes = include_bytes!("../test-data/image/rectangle2000x1800-rotated.jpg");
@@ -855,7 +845,7 @@ mod tests {
         // Do this in parallel to speed up the test a bit
         // (it still takes very long though)
         let bytes2 = bytes.clone();
-        let join_handle = async_std::task::spawn(async move {
+        let join_handle = tokio::task::spawn(async move {
             let img_rotated = send_image_check_mediaquality(
                 Some("0"),
                 &bytes2,
@@ -883,10 +873,10 @@ mod tests {
         .unwrap();
         assert_correct_rotation(&img_rotated);
 
-        join_handle.await;
+        join_handle.await.unwrap();
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_recode_image_3() {
         let bytes = include_bytes!("../test-data/image/rectangle200x180-rotated.jpg");
         let img_rotated = send_image_check_mediaquality(Some("0"), bytes, 200, 180, 270, 180, 200)
@@ -934,10 +924,10 @@ mod tests {
             .await?;
         let file = alice.get_blobdir().join("file.jpg");
 
-        File::create(&file).await?.write_all(bytes).await?;
-        let img = image::open(&file)?;
-        assert_eq!(img.width(), original_width);
-        assert_eq!(img.height(), original_height);
+        fs::write(&file, &bytes)
+            .await
+            .context("failed to write file")?;
+        check_image_size(&file, original_width, original_height);
 
         let blob = BlobObject::new_from_path(&alice, &file).await?;
         assert_eq!(blob.get_exif_orientation(&alice).unwrap_or(0), orientation);
@@ -949,9 +939,11 @@ mod tests {
         let alice_msg = alice.get_last_msg().await;
         assert_eq!(alice_msg.get_width() as u32, compressed_width);
         assert_eq!(alice_msg.get_height() as u32, compressed_height);
-        let img = image::open(alice_msg.get_file(&alice).unwrap())?;
-        assert_eq!(img.width() as u32, compressed_width);
-        assert_eq!(img.height() as u32, compressed_height);
+        check_image_size(
+            alice_msg.get_file(&alice).unwrap(),
+            compressed_width,
+            compressed_height,
+        );
 
         let bob_msg = bob.recv_msg(&sent).await;
         assert_eq!(bob_msg.get_width() as u32, compressed_width);
@@ -961,19 +953,17 @@ mod tests {
         let blob = BlobObject::new_from_path(&bob, &file).await?;
         assert_eq!(blob.get_exif_orientation(&bob).unwrap_or(0), 0);
 
-        let img = image::open(file)?;
-        assert_eq!(img.width() as u32, compressed_width);
-        assert_eq!(img.height() as u32, compressed_height);
+        let img = check_image_size(file, compressed_width, compressed_height);
         Ok(img)
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_increation_in_blobdir() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "abc").await?;
 
         let file = t.get_blobdir().join("anyfile.dat");
-        File::create(&file).await?.write_all("bla".as_ref()).await?;
+        fs::write(&file, b"bla").await?;
         let mut msg = Message::new(Viewtype::File);
         msg.set_file(file.to_str().unwrap(), None);
         let prepared_id = chat::prepare_msg(&t, chat_id, &mut msg).await?;
@@ -986,14 +976,14 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_increation_not_blobdir() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "abc").await?;
         assert_ne!(t.get_blobdir().to_str(), t.dir.path().to_str());
 
         let file = t.dir.path().join("anyfile.dat");
-        File::create(&file).await?.write_all("bla".as_ref()).await?;
+        fs::write(&file, b"bla").await?;
         let mut msg = Message::new(Viewtype::File);
         msg.set_file(file.to_str().unwrap(), None);
         assert!(chat::prepare_msg(&t, chat_id, &mut msg).await.is_err());

src/chat.rs

@@ -2,11 +2,11 @@
 
 use std::collections::HashMap;
 use std::convert::{TryFrom, TryInto};
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::{Duration, SystemTime};
 
 use anyhow::{bail, ensure, Context as _, Result};
-use async_std::path::{Path, PathBuf};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
 
@@ -20,12 +20,6 @@ use crate::constants::{
 };
 use crate::contact::{Contact, ContactId, Origin, VerifiedStatus};
 use crate::context::Context;
-use crate::dc_receive_imf::ReceivedMsg;
-use crate::dc_tools::{
-    dc_create_id, dc_create_outgoing_rfc724_mid, dc_create_smeared_timestamp,
-    dc_create_smeared_timestamps, dc_get_abs_path, dc_gm2local_offset, improve_single_line_input,
-    time, IsNoneOrEmpty,
-};
 use crate::ephemeral::Timer as EphemeralTimer;
 use crate::events::EventType;
 use crate::html::new_html_mimepart;
@@ -34,9 +28,14 @@ use crate::mimefactory::MimeFactory;
 use crate::mimeparser::SystemMessage;
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateVerifiedStatus};
+use crate::receive_imf::ReceivedMsg;
 use crate::scheduler::InterruptInfo;
 use crate::smtp::send_msg_to_smtp;
 use crate::stock_str;
+use crate::tools::{
+    create_id, create_outgoing_rfc724_mid, create_smeared_timestamp, create_smeared_timestamps,
+    get_abs_path, gm2local_offset, improve_single_line_input, time, IsNoneOrEmpty,
+};
 use crate::webxdc::WEBXDC_SUFFIX;
 use crate::{location, sql};
 
@@ -233,7 +232,7 @@ impl ChatId {
                     grpname,
                     grpid,
                     create_blocked,
-                    dc_create_smeared_timestamp(context).await,
+                    create_smeared_timestamp(context).await,
                     create_protected,
                     param.unwrap_or_default(),
                 ],
@@ -435,7 +434,7 @@ impl ChatId {
                 self,
                 &msg_text,
                 cmd,
-                dc_create_smeared_timestamp(context).await,
+                create_smeared_timestamp(context).await,
                 None,
                 None,
                 None,
@@ -1134,7 +1133,7 @@ impl Chat {
     pub async fn get_profile_image(&self, context: &Context) -> Result<Option<PathBuf>> {
         if let Some(image_rel) = self.param.get(Param::ProfileImage) {
             if !image_rel.is_empty() {
-                return Ok(Some(dc_get_abs_path(context, image_rel)));
+                return Ok(Some(get_abs_path(context, image_rel)));
             }
         } else if self.typ == Chattype::Single {
             let contacts = get_chat_contacts(context, self.id).await?;
@@ -1145,7 +1144,7 @@ impl Chat {
             }
         } else if self.typ == Chattype::Broadcast {
             if let Ok(image_rel) = get_broadcast_icon(context).await {
-                return Ok(Some(dc_get_abs_path(context, image_rel)));
+                return Ok(Some(get_abs_path(context, image_rel)));
             }
         }
         Ok(None)
@@ -1271,7 +1270,7 @@ impl Chat {
                 Chattype::Group => Some(self.grpid.as_str()),
                 _ => None,
             };
-            dc_create_outgoing_rfc724_mid(grpid, &from)
+            create_outgoing_rfc724_mid(grpid, &from)
         };
 
         if self.typ == Chattype::Single {
@@ -1748,7 +1747,7 @@ impl ChatIdBlocked {
             _ => (),
         }
 
-        let created_timestamp = dc_create_smeared_timestamp(context).await;
+        let created_timestamp = create_smeared_timestamp(context).await;
         let chat_id = context
             .sql
             .transaction(move |transaction| {
@@ -1901,7 +1900,7 @@ async fn prepare_msg_common(
             context,
             msg,
             update_msg_id,
-            dc_create_smeared_timestamp(context).await,
+            create_smeared_timestamp(context).await,
         )
         .await?;
     msg.chat_id = chat_id;
@@ -1995,7 +1994,7 @@ async fn prepare_send_msg(
     chat_id: ChatId,
     msg: &mut Message,
 ) -> Result<Option<i64>> {
-    // dc_prepare_msg() leaves the message state to OutPreparing, we
+    // prepare_msg() leaves the message state to OutPreparing, we
     // only have to change the state to OutPending in this case.
     // Otherwise we still have to prepare the message, which will set
     // the state to OutPending.
@@ -2179,7 +2178,7 @@ pub async fn send_videochat_invitation(context: &Context, chat_id: ChatId) -> Re
         bail!("webrtc_instance not set");
     };
 
-    let instance = Message::create_webrtc_instance(&instance, &dc_create_id());
+    let instance = Message::create_webrtc_instance(&instance, &create_id());
 
     let mut msg = Message::new(Viewtype::VideochatInvitation);
     msg.param.set(Param::WebrtcRoom, &instance);
@@ -2242,7 +2241,7 @@ pub async fn get_chat_msgs(
 
         let mut ret = Vec::new();
         let mut last_day = 0;
-        let cnv_to_local = dc_gm2local_offset();
+        let cnv_to_local = gm2local_offset();
 
         for (ts, curr_id) in sorted_rows {
             if (flags & DC_GCM_ADDDAYMARKER) != 0 {
@@ -2538,7 +2537,7 @@ pub async fn create_group_chat(
     let chat_name = improve_single_line_input(chat_name);
     ensure!(!chat_name.is_empty(), "Invalid chat name");
 
-    let grpid = dc_create_id();
+    let grpid = create_id();
 
     let row_id = context
         .sql
@@ -2550,7 +2549,7 @@ pub async fn create_group_chat(
                 Chattype::Group,
                 chat_name,
                 grpid,
-                dc_create_smeared_timestamp(context).await,
+                create_smeared_timestamp(context).await,
             ],
         )
         .await?;
@@ -2597,7 +2596,7 @@ async fn find_unused_broadcast_list_name(context: &Context) -> Result<String> {
 /// Creates a new broadcast list.
 pub async fn create_broadcast_list(context: &Context) -> Result<ChatId> {
     let chat_name = find_unused_broadcast_list_name(context).await?;
-    let grpid = dc_create_id();
+    let grpid = create_id();
     let row_id = context
         .sql
         .insert(
@@ -2608,7 +2607,7 @@ pub async fn create_broadcast_list(context: &Context) -> Result<ChatId> {
                 Chattype::Broadcast,
                 chat_name,
                 grpid,
-                dc_create_smeared_timestamp(context).await,
+                create_smeared_timestamp(context).await,
             ],
         )
         .await?;
@@ -3049,7 +3048,7 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
     chat_id.unarchive_if_not_muted(context).await?;
     if let Ok(mut chat) = Chat::load_from_db(context, chat_id).await {
         ensure!(chat.can_send(context).await?, "cannot send to {}", chat_id);
-        curr_timestamp = dc_create_smeared_timestamps(context, msg_ids.len()).await;
+        curr_timestamp = create_smeared_timestamps(context, msg_ids.len()).await;
         let ids = context
             .sql
             .query_map(
@@ -3244,12 +3243,12 @@ pub async fn add_device_msg_with_importance(
     if let Some(msg) = msg {
         chat_id = ChatId::get_for_contact(context, ContactId::DEVICE).await?;
 
-        let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
+        let rfc724_mid = create_outgoing_rfc724_mid(None, "@device");
         msg.try_calc_and_set_dimensions(context).await.ok();
         prepare_msg_blob(context, msg).await?;
         chat_id.unarchive_if_not_muted(context).await?;
 
-        let timestamp_sent = dc_create_smeared_timestamp(context).await;
+        let timestamp_sent = create_smeared_timestamp(context).await;
 
         // makes sure, the added message is the last one,
         // even if the date is wrong (useful esp. when warning about bad dates)
@@ -3382,7 +3381,7 @@ pub(crate) async fn add_info_msg_with_cmd(
     parent: Option<&Message>,
     from_id: Option<ContactId>,
 ) -> Result<MsgId> {
-    let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
+    let rfc724_mid = create_outgoing_rfc724_mid(None, "@device");
     let ephemeral_timer = chat_id.get_ephemeral_timer(context).await?;
 
     let mut param = Params::new();
@@ -3459,15 +3458,13 @@ pub(crate) async fn update_msg_text_and_timestamp(
 mod tests {
     use super::*;
 
-    use crate::chatlist::{dc_get_archived_cnt, Chatlist};
+    use crate::chatlist::{get_archived_cnt, Chatlist};
     use crate::constants::{DC_GCL_ARCHIVED_ONLY, DC_GCL_NO_SPECIALS};
     use crate::contact::Contact;
-    use crate::dc_receive_imf::dc_receive_imf;
+    use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
-    use async_std::fs::File;
-    use async_std::prelude::*;
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_chat_info() {
         let t = TestContext::new().await;
         let chat = t.create_chat_with_contact("bob", "bob@example.com").await;
@@ -3498,7 +3495,7 @@ mod tests {
         assert_eq!(info, loaded);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_draft_no_draft() {
         let t = TestContext::new().await;
         let chat = t.get_self_chat().await;
@@ -3506,14 +3503,14 @@ mod tests {
         assert!(draft.is_none());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_draft_special_chat_id() {
         let t = TestContext::new().await;
         let draft = DC_CHAT_ID_LAST_SPECIAL.get_draft(&t).await.unwrap();
         assert!(draft.is_none());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_draft_no_chat() {
         // This is a weird case, maybe this should be an error but we
         // do not get this info from the database currently.
@@ -3522,7 +3519,7 @@ mod tests {
         assert!(draft.is_none());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_draft() {
         let t = TestContext::new().await;
         let chat_id = &t.get_self_chat().await.id;
@@ -3536,7 +3533,7 @@ mod tests {
         assert_eq!(msg_text, draft_text);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_delete_draft() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "abc").await?;
@@ -3557,7 +3554,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_forwarding_draft_failing() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat_id = &t.get_self_chat().await.id;
@@ -3571,7 +3568,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_draft_stable_ids() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat_id = &t.get_self_chat().await.id;
@@ -3616,7 +3613,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_change_quotes_on_reused_message_object() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "chat").await?;
@@ -3668,7 +3665,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_contact_to_chat_ex_add_self() {
         // Adding self to a contact should succeed, even though it's pointless.
         let t = TestContext::new_alice().await;
@@ -3681,7 +3678,7 @@ mod tests {
         assert_eq!(added, false);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_modify_chat_multi_device() -> Result<()> {
         let a1 = TestContext::new_alice().await;
         let a2 = TestContext::new_alice().await;
@@ -3756,7 +3753,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_modify_chat_disordered() -> Result<()> {
         // Alice creates a group with Bob, Claire and Daisy and then removes Claire and Daisy
         // (sleep() is needed as otherwise smeared time from Alice looks to Bob like messages from the future which are all set to "now" then)
@@ -3770,47 +3767,47 @@ mod tests {
         send_text_msg(&alice, alice_chat_id, "populate".to_string()).await?;
 
         add_contact_to_chat(&alice, alice_chat_id, bob_id).await?;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
         let add1 = alice.pop_sent_msg().await;
 
         add_contact_to_chat(&alice, alice_chat_id, claire_id).await?;
         let add2 = alice.pop_sent_msg().await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         add_contact_to_chat(&alice, alice_chat_id, daisy_id).await?;
         let add3 = alice.pop_sent_msg().await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 4);
 
         remove_contact_from_chat(&alice, alice_chat_id, claire_id).await?;
         let remove1 = alice.pop_sent_msg().await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         remove_contact_from_chat(&alice, alice_chat_id, daisy_id).await?;
         let remove2 = alice.pop_sent_msg().await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 2);
 
         // Bob receives the add and deletion messages out of order
         let bob = TestContext::new_bob().await;
         bob.recv_msg(&add1).await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         bob.recv_msg(&add3).await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         let bob_chat_id = bob.recv_msg(&add2).await.chat_id;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         assert_eq!(get_chat_contacts(&bob, bob_chat_id).await?.len(), 4);
 
         bob.recv_msg(&remove2).await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         bob.recv_msg(&remove1).await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         assert_eq!(get_chat_contacts(&bob, bob_chat_id).await?.len(), 2);
 
@@ -3818,7 +3815,7 @@ mod tests {
     }
 
     /// Test that group updates are robust to lost messages and eventual out of order arrival.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_modify_chat_lost() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
@@ -3833,11 +3830,11 @@ mod tests {
 
         send_text_msg(&alice, alice_chat_id, "populate".to_string()).await?;
         let add = alice.pop_sent_msg().await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         remove_contact_from_chat(&alice, alice_chat_id, claire_id).await?;
         let remove1 = alice.pop_sent_msg().await;
-        async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1100)).await;
 
         remove_contact_from_chat(&alice, alice_chat_id, daisy_id).await?;
         let remove2 = alice.pop_sent_msg().await;
@@ -3860,7 +3857,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_leave_group() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -3889,7 +3886,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_remove_contact_for_single() {
         let ctx = TestContext::new_alice().await;
         let bob = Contact::create(&ctx, "", "bob@f.br").await.unwrap();
@@ -3913,7 +3910,7 @@ mod tests {
         assert_eq!(get_chat_contacts(&ctx, chat.id).await.unwrap().len(), 1);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_self_talk() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat = &t.get_self_chat().await;
@@ -3944,7 +3941,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_device_msg_unlabelled() {
         let t = TestContext::new().await;
 
@@ -3979,7 +3976,7 @@ mod tests {
         assert_eq!(msg2.chat_id.get_msg_cnt(&t).await.unwrap(), 2);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_device_msg_labelled() -> Result<()> {
         let t = TestContext::new().await;
 
@@ -4029,7 +4026,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_device_msg_label_only() {
         let t = TestContext::new().await;
         let res = add_device_msg(&t, Some(""), None).await;
@@ -4049,7 +4046,7 @@ mod tests {
         assert!(!msg_id.as_ref().unwrap().is_unset());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_was_device_msg_ever_added() {
         let t = TestContext::new().await;
         add_device_msg(&t, Some("some-label"), None).await.ok();
@@ -4069,7 +4066,7 @@ mod tests {
         assert!(was_device_msg_ever_added(&t, "").await.is_err());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_delete_device_chat() {
         let t = TestContext::new().await;
 
@@ -4089,7 +4086,7 @@ mod tests {
         assert_eq!(chatlist_len(&t, 0).await, 0)
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_device_chat_cannot_sent() {
         let t = TestContext::new().await;
         t.update_device_chats().await.unwrap();
@@ -4106,7 +4103,7 @@ mod tests {
         assert!(forward_msgs(&t, &[msg_id], device_chat_id).await.is_err());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_delete_and_reset_all_device_msgs() {
         let t = TestContext::new().await;
         let mut msg = Message::new(Viewtype::Text);
@@ -4138,7 +4135,7 @@ mod tests {
             .len()
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_archive() {
         // create two chats
         let t = TestContext::new().await;
@@ -4241,12 +4238,12 @@ mod tests {
         assert_eq!(chatlist_len(&t, DC_GCL_ARCHIVED_ONLY).await, 1);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_unarchive_if_muted() -> Result<()> {
         let t = TestContext::new_alice().await;
 
         async fn msg_from_bob(t: &TestContext, num: u32) -> Result<()> {
-            dc_receive_imf(
+            receive_imf(
                 t,
                 format!(
                     "From: bob@example.net\n\
@@ -4269,17 +4266,17 @@ mod tests {
         let chat_id = t.get_last_msg().await.get_chat_id();
         chat_id.accept(&t).await?;
         chat_id.set_visibility(&t, ChatVisibility::Archived).await?;
-        assert_eq!(dc_get_archived_cnt(&t).await?, 1);
+        assert_eq!(get_archived_cnt(&t).await?, 1);
 
         // not muted chat is unarchived on receiving a message
         msg_from_bob(&t, 2).await?;
-        assert_eq!(dc_get_archived_cnt(&t).await?, 0);
+        assert_eq!(get_archived_cnt(&t).await?, 0);
 
         // forever muted chat is not unarchived on receiving a message
         chat_id.set_visibility(&t, ChatVisibility::Archived).await?;
         set_muted(&t, chat_id, MuteDuration::Forever).await?;
         msg_from_bob(&t, 3).await?;
-        assert_eq!(dc_get_archived_cnt(&t).await?, 1);
+        assert_eq!(get_archived_cnt(&t).await?, 1);
 
         // otherwise muted chat is not unarchived on receiving a message
         set_muted(
@@ -4293,7 +4290,7 @@ mod tests {
         )
         .await?;
         msg_from_bob(&t, 4).await?;
-        assert_eq!(dc_get_archived_cnt(&t).await?, 1);
+        assert_eq!(get_archived_cnt(&t).await?, 1);
 
         // expired mute will unarchive the chat
         set_muted(
@@ -4307,19 +4304,19 @@ mod tests {
         )
         .await?;
         msg_from_bob(&t, 5).await?;
-        assert_eq!(dc_get_archived_cnt(&t).await?, 0);
+        assert_eq!(get_archived_cnt(&t).await?, 0);
 
         // no unarchiving on sending to muted chat or on adding info messages to muted chat
         chat_id.set_visibility(&t, ChatVisibility::Archived).await?;
         set_muted(&t, chat_id, MuteDuration::Forever).await?;
         send_text_msg(&t, chat_id, "out".to_string()).await?;
         add_info_msg(&t, chat_id, "info", time()).await?;
-        assert_eq!(dc_get_archived_cnt(&t).await?, 1);
+        assert_eq!(get_archived_cnt(&t).await?, 1);
 
         // finally, unarchive on sending to not muted chat
         set_muted(&t, chat_id, MuteDuration::NotMuted).await?;
         send_text_msg(&t, chat_id, "out2".to_string()).await?;
-        assert_eq!(dc_get_archived_cnt(&t).await?, 0);
+        assert_eq!(get_archived_cnt(&t).await?, 0);
 
         Ok(())
     }
@@ -4335,7 +4332,7 @@ mod tests {
         result
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_pinned() {
         let t = TestContext::new().await;
 
@@ -4347,9 +4344,9 @@ mod tests {
             .await
             .unwrap()
             .chat_id;
-        async_std::task::sleep(std::time::Duration::from_millis(1000)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
         let chat_id2 = t.get_self_chat().await.id;
-        async_std::task::sleep(std::time::Duration::from_millis(1000)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
         let chat_id3 = create_group_chat(&t, ProtectionStatus::Unprotected, "foo")
             .await
             .unwrap();
@@ -4392,7 +4389,7 @@ mod tests {
         assert_eq!(chatlist, vec![chat_id3, chat_id2, chat_id1]);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_set_chat_name() {
         let t = TestContext::new().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo")
@@ -4410,7 +4407,7 @@ mod tests {
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_same_chat_twice() {
         let context = TestContext::new().await;
         let contact1 = Contact::create(&context.ctx, "bob", "bob@mail.de")
@@ -4433,7 +4430,7 @@ mod tests {
         assert_eq!(chat2.name, chat.name);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_shall_attach_selfavatar() -> Result<()> {
         let t = TestContext::new().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
@@ -4451,7 +4448,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_set_mute_duration() {
         let t = TestContext::new().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo")
@@ -4502,7 +4499,7 @@ mod tests {
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_info_msg() -> Result<()> {
         let t = TestContext::new().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
@@ -4519,7 +4516,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_info_msg_with_cmd() -> Result<()> {
         let t = TestContext::new().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
@@ -4549,7 +4546,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_set_protection() {
         let t = TestContext::new_alice().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo")
@@ -4617,7 +4614,7 @@ mod tests {
         assert_eq!(msg.get_state(), MessageState::OutDelivered); // as bcc-self is disabled and there is nobody else in the chat
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_lookup_by_contact_id() {
         let ctx = TestContext::new_alice().await;
 
@@ -4660,7 +4657,7 @@ mod tests {
         assert!(found.is_none());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_lookup_self_by_contact_id() {
         let ctx = TestContext::new_alice().await;
 
@@ -4679,7 +4676,7 @@ mod tests {
         assert_eq!(chat.blocked, Blocked::Not);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_group_with_removed_message_id() -> Result<()> {
         // Alice creates a group with Bob, sends a message to bob
         let alice = TestContext::new_alice().await;
@@ -4706,7 +4703,7 @@ mod tests {
         assert_eq!(msg.match_indices("Gr.").count(), 1);
 
         // Bob receives this message, he may detect group by `References:`- or `Chat-Group:`-header
-        dc_receive_imf(&bob, msg.as_bytes(), false).await.unwrap();
+        receive_imf(&bob, msg.as_bytes(), false).await.unwrap();
         let msg = bob.get_last_msg().await;
 
         let bob_chat = Chat::load_from_db(&bob, msg.chat_id).await?;
@@ -4725,7 +4722,7 @@ mod tests {
         assert_eq!(msg.match_indices("Chat-").count(), 0);
 
         // Alice receives this message - she can still detect the group by the `References:`-header
-        dc_receive_imf(&alice, msg.as_bytes(), false).await.unwrap();
+        receive_imf(&alice, msg.as_bytes(), false).await.unwrap();
         let msg = alice.get_last_msg().await;
         assert_eq!(msg.chat_id, alice_chat_id);
         assert_eq!(msg.text, Some("ho!".to_string()));
@@ -4733,12 +4730,12 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_marknoticed_chat() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat = t.create_chat_with_contact("bob", "bob@example.org").await;
 
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: bob@example.org\n\
                  To: alice@example.org\n\
@@ -4778,14 +4775,14 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_contact_request_fresh_messages() -> Result<()> {
         let t = TestContext::new_alice().await;
 
         let chats = Chatlist::try_load(&t, 0, None, None).await?;
         assert_eq!(chats.len(), 0);
 
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: bob@example.org\n\
                  To: alice@example.org\n\
@@ -4828,11 +4825,11 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_contact_request_archive() -> Result<()> {
         let t = TestContext::new_alice().await;
 
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: bob@example.org\n\
                  To: alice@example.org\n\
@@ -4849,7 +4846,7 @@ mod tests {
         assert_eq!(chats.len(), 1);
         let chat_id = chats.get_chat_id(0)?;
         assert!(Chat::load_from_db(&t, chat_id).await?.is_contact_request());
-        assert_eq!(dc_get_archived_cnt(&t).await?, 0);
+        assert_eq!(get_archived_cnt(&t).await?, 0);
 
         // archive request without accepting or blocking
         chat_id.set_visibility(&t, ChatVisibility::Archived).await?;
@@ -4858,7 +4855,7 @@ mod tests {
         assert_eq!(chats.len(), 1);
         let chat_id = chats.get_chat_id(0)?;
         assert!(chat_id.is_archived_link());
-        assert_eq!(dc_get_archived_cnt(&t).await?, 1);
+        assert_eq!(get_archived_cnt(&t).await?, 1);
 
         let chats = Chatlist::try_load(&t, DC_GCL_ARCHIVED_ONLY, None, None).await?;
         assert_eq!(chats.len(), 1);
@@ -4868,7 +4865,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_classic_email_chat() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
@@ -4879,7 +4876,7 @@ mod tests {
             .unwrap();
 
         // Alice receives a classic (non-chat) message from Bob.
-        dc_receive_imf(
+        receive_imf(
             &alice,
             b"From: bob@example.org\n\
                  To: alice@example.org\n\
@@ -4913,7 +4910,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_chat_get_color() -> Result<()> {
         let t = TestContext::new().await;
         let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat").await?;
@@ -4936,7 +4933,7 @@ mod tests {
         let bob_chat = bob.create_chat(&alice).await;
 
         let file = alice.get_blobdir().join(filename);
-        File::create(&file).await?.write_all(bytes).await?;
+        tokio::fs::write(&file, bytes).await?;
 
         let mut msg = Message::new(Viewtype::Sticker);
         msg.set_file(file.to_str().unwrap(), None);
@@ -4956,7 +4953,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sticker_png() -> Result<()> {
         test_sticker(
             "sticker.png",
@@ -4967,7 +4964,7 @@ mod tests {
         .await
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sticker_jpeg() -> Result<()> {
         test_sticker(
             "sticker.jpg",
@@ -4978,7 +4975,7 @@ mod tests {
         .await
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sticker_gif() -> Result<()> {
         test_sticker(
             "sticker.gif",
@@ -4989,7 +4986,7 @@ mod tests {
         .await
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sticker_forward() -> Result<()> {
         // create chats
         let alice = TestContext::new_alice().await;
@@ -5001,7 +4998,7 @@ mod tests {
         let file_name = "sticker.jpg";
         let bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
         let file = alice.get_blobdir().join(file_name);
-        File::create(&file).await?.write_all(bytes).await?;
+        tokio::fs::write(&file, bytes).await?;
         let mut msg = Message::new(Viewtype::Sticker);
         msg.set_file(file.to_str().unwrap(), None);
 
@@ -5020,7 +5017,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_forward() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -5041,7 +5038,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_forward_info_msg() -> Result<()> {
         let t = TestContext::new_alice().await;
 
@@ -5067,7 +5064,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_forward_quote() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -5102,7 +5099,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_forward_group() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -5152,7 +5149,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_only_minimal_data_are_forwarded() -> Result<()> {
         // send a message from Alice to a group with Bob
         let alice = TestContext::new_alice().await;
@@ -5194,7 +5191,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_resend_own_message() -> Result<()> {
         // Alice creates group with Bob and sends an initial message
         let alice = TestContext::new_alice().await;
@@ -5247,7 +5244,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_resend_foreign_message_fails() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let alice_grp = create_group_chat(&alice, ProtectionStatus::Unprotected, "grp").await?;
@@ -5266,7 +5263,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_resend_opportunistically_encryption() -> Result<()> {
         // Alice creates group with Bob and sends an initial message
         let alice = TestContext::new_alice().await;
@@ -5303,7 +5300,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_resend_info_message_fails() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let alice_grp = create_group_chat(&alice, ProtectionStatus::Unprotected, "grp").await?;
@@ -5327,7 +5324,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_can_send_group() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = Contact::create(&alice, "", "bob@f.br").await?;
@@ -5353,7 +5350,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_broadcast() -> Result<()> {
         // create two context, send two messages so both know the other
         let alice = TestContext::new_alice().await;
@@ -5396,7 +5393,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_for_contact_with_blocked() -> Result<()> {
         let t = TestContext::new().await;
         let (contact_id, _) =
@@ -5430,7 +5427,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_chat_get_encryption_info() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;

src/chatlist.rs

@@ -240,7 +240,7 @@ impl Chatlist {
             ids
         };
 
-        if add_archived_link_item && dc_get_archived_cnt(context).await? > 0 {
+        if add_archived_link_item && get_archived_cnt(context).await? > 0 {
             if ids.is_empty() && flag_add_alldone_hint {
                 ids.push((DC_CHAT_ID_ALLDONE_HINT, None));
             }
@@ -355,7 +355,7 @@ impl Chatlist {
 }
 
 /// Returns the number of archived chats
-pub async fn dc_get_archived_cnt(context: &Context) -> Result<usize> {
+pub async fn get_archived_cnt(context: &Context) -> Result<usize> {
     let count = context
         .sql
         .count(
@@ -371,12 +371,12 @@ mod tests {
     use super::*;
 
     use crate::chat::{create_group_chat, get_chat_contacts, ProtectionStatus};
-    use crate::dc_receive_imf::dc_receive_imf;
     use crate::message::Viewtype;
+    use crate::receive_imf::receive_imf;
     use crate::stock_str::StockMessage;
     use crate::test_utils::TestContext;
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_try_load() {
         let t = TestContext::new().await;
         let chat_id1 = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat")
@@ -432,7 +432,7 @@ mod tests {
         assert_eq!(chats.len(), 1);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sort_self_talk_up_on_forward() {
         let t = TestContext::new().await;
         t.update_device_chats().await.unwrap();
@@ -457,7 +457,7 @@ mod tests {
             .is_self_talk());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_special_chat_names() {
         let t = TestContext::new().await;
         t.update_device_chats().await.unwrap();
@@ -488,12 +488,12 @@ mod tests {
         assert_eq!(chats.len(), 1);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_single_chat() -> anyhow::Result<()> {
         let t = TestContext::new_alice().await;
 
         // receive a one-to-one-message
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: Bob Authname <bob@example.org>\n\
                  To: alice@example.org\n\
@@ -548,12 +548,12 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_single_chat_without_authname() -> anyhow::Result<()> {
         let t = TestContext::new_alice().await;
 
         // receive a one-to-one-message without authname set
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: bob@example.org\n\
                  To: alice@example.org\n\
@@ -610,7 +610,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_summary_unwrap() {
         let t = TestContext::new().await;
         let chat_id1 = create_group_chat(&t, ProtectionStatus::Unprotected, "a chat")

src/config.rs

@@ -8,10 +8,10 @@ use crate::blob::BlobObject;
 use crate::constants::DC_VERSION_STR;
 use crate::contact::addr_cmp;
 use crate::context::Context;
-use crate::dc_tools::{dc_get_abs_path, improve_single_line_input, EmailAddress};
 use crate::events::EventType;
 use crate::mimefactory::RECOMMENDED_FILE_SIZE;
 use crate::provider::{get_provider_by_id, Provider};
+use crate::tools::{get_abs_path, improve_single_line_input, EmailAddress};
 
 /// The available configuration keys.
 #[derive(
@@ -196,7 +196,7 @@ impl Context {
         let value = match key {
             Config::Selfavatar => {
                 let rel_path = self.sql.get_raw_config(key).await?;
-                rel_path.map(|p| dc_get_abs_path(self, &p).to_string_lossy().into_owned())
+                rel_path.map(|p| get_abs_path(self, &p).to_string_lossy().into_owned())
             }
             Config::SysVersion => Some((&*DC_VERSION_STR).clone()),
             Config::SysMsgsizeMaxRecommended => Some(format!("{}", RECOMMENDED_FILE_SIZE)),
@@ -437,9 +437,8 @@ mod tests {
     use std::string::ToString;
 
     use crate::constants;
-    use crate::dc_receive_imf::dc_receive_imf;
     use crate::test_utils::TestContext;
-    use crate::test_utils::TestContextManager;
+
     use num_traits::FromPrimitive;
 
     #[test]
@@ -454,7 +453,7 @@ mod tests {
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_media_quality_config_option() {
         let t = TestContext::new().await;
         let media_quality = t.get_config_int(Config::MediaQuality).await.unwrap();
@@ -471,7 +470,7 @@ mod tests {
         assert_eq!(media_quality, constants::MediaQuality::Worse);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ui_config() -> Result<()> {
         let t = TestContext::new().await;
 
@@ -493,7 +492,7 @@ mod tests {
     }
 
     /// Regression test for https://github.com/deltachat/deltachat-core-rust/issues/3012
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_set_config_bool() -> Result<()> {
         let t = TestContext::new().await;
 
@@ -505,7 +504,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_self_addrs() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
@@ -557,68 +556,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[async_std::test]
-    async fn test_change_primary_self_addr() -> Result<()> {
-        let mut tcm = TestContextManager::new().await;
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-
-        // Alice sends a message to Bob
-        let alice_bob_chat = alice.create_chat(&bob).await;
-        let sent = alice.send_text(alice_bob_chat.id, "Hi").await;
-        let bob_msg = bob.recv_msg(&sent).await;
-        bob_msg.chat_id.accept(&bob).await?;
-        assert_eq!(bob_msg.text.unwrap(), "Hi");
-
-        // Alice changes her self address and reconfigures
-        // (ensure_secret_key_exists() is called during configure)
-        alice
-            .set_primary_self_addr("alice@someotherdomain.xyz")
-            .await?;
-        crate::e2ee::ensure_secret_key_exists(&alice).await?;
-
-        assert_eq!(
-            alice.get_primary_self_addr().await?,
-            "alice@someotherdomain.xyz"
-        );
-
-        // Bob sends a message to Alice, encrypting to her previous key
-        let sent = bob.send_text(bob_msg.chat_id, "hi back").await;
-
-        // Alice set up message forwarding so that she still receives
-        // the message with her new address
-        let alice_msg = alice.recv_msg(&sent).await;
-        assert_eq!(alice_msg.text, Some("hi back".to_string()));
-        assert_eq!(alice_msg.get_showpadlock(), true);
-        assert_eq!(alice_msg.chat_id, alice_bob_chat.id);
-
-        // Even if Bob sends a message to Alice without In-Reply-To,
-        // it's still assigned to the 1:1 chat with Bob and not to
-        // a group (without secondary addresses, an ad-hoc group
-        // would be created)
-        dc_receive_imf(
-            &alice,
-            b"From: bob@example.net
-To: alice@example.org
-Chat-Version: 1.0
-Message-ID: <456@example.com>
-
-Message w/out In-Reply-To
-",
-            false,
-        )
-        .await?;
-
-        let alice_msg = alice.get_last_msg().await;
-
-        assert_eq!(
-            alice_msg.text,
-            Some("Message w/out In-Reply-To".to_string())
-        );
-        assert_eq!(alice_msg.get_showpadlock(), false);
-        assert_eq!(alice_msg.chat_id, alice_bob_chat.id);
-
-        Ok(())
-    }
 }

src/configure.rs

@@ -6,22 +6,23 @@ mod read_url;
 mod server_params;
 
 use anyhow::{bail, ensure, Context as _, Result};
-use async_std::prelude::*;
-use async_std::task;
+use futures::FutureExt;
+use futures_lite::FutureExt as _;
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
+use tokio::task;
 
 use crate::config::Config;
 use crate::context::Context;
-use crate::dc_tools::{time, EmailAddress};
 use crate::imap::Imap;
 use crate::job;
 use crate::login_param::{CertificateChecks, LoginParam, ServerLoginParam, Socks5Config};
 use crate::message::{Message, Viewtype};
-use crate::oauth2::dc_get_oauth2_addr;
+use crate::oauth2::get_oauth2_addr;
 use crate::provider::{Protocol, Socket, UsernamePattern};
 use crate::scheduler::InterruptInfo;
 use crate::smtp::Smtp;
 use crate::stock_str;
+use crate::tools::{time, EmailAddress};
 use crate::{chat, e2ee, provider};
 
 use auto_mozilla::moz_autoconfigure;
@@ -55,8 +56,6 @@ impl Context {
 
     /// Configures this account with the currently set parameters.
     pub async fn configure(&self) -> Result<()> {
-        use futures::future::FutureExt;
-
         ensure!(
             self.scheduler.read().await.is_none(),
             "cannot configure, already running"
@@ -155,9 +154,9 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
     // IMAP and SMTP or not at all.
     if param.imap.oauth2 && !socks5_enabled {
         // the used oauth2 addr may differ, check this.
-        // if dc_get_oauth2_addr() is not available in the oauth2 implementation, just use the given one.
+        // if get_oauth2_addr() is not available in the oauth2 implementation, just use the given one.
         progress!(ctx, 10);
-        if let Some(oauth2_addr) = dc_get_oauth2_addr(ctx, &param.addr, &param.imap.password)
+        if let Some(oauth2_addr) = get_oauth2_addr(ctx, &param.addr, &param.imap.password)
             .await?
             .and_then(|e| e.parse().ok())
         {
@@ -404,7 +403,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
     progress!(ctx, 850);
 
     // Wait for SMTP configuration
-    match smtp_config_task.await {
+    match smtp_config_task.await.unwrap() {
         Ok(smtp_param) => {
             param.smtp = smtp_param;
         }
@@ -417,6 +416,9 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
 
     let create_mvbox = ctx.should_watch_mvbox().await?;
 
+    // Send client ID as soon as possible before doing anything else.
+    imap.determine_capabilities(ctx).await?;
+
     imap.configure_folders(ctx, create_mvbox).await?;
 
     imap.select_with_uidvalidity(ctx, "INBOX")
@@ -447,7 +449,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
     ctx.interrupt_inbox(InterruptInfo::new(false)).await;
 
     progress!(ctx, 940);
-    update_device_chats_handle.await?;
+    update_device_chats_handle.await??;
 
     ctx.sql.set_raw_config_bool("configured", true).await?;
 
@@ -549,7 +551,7 @@ async fn try_imap_one_param(
     );
     info!(context, "Trying: {}", inf);
 
-    let (_s, r) = async_std::channel::bounded(1);
+    let (_s, r) = async_channel::bounded(1);
 
     let mut imap = match Imap::new(param, socks5_config.clone(), addr, provider_strict_tls, r).await
     {
@@ -634,10 +636,13 @@ async fn nicer_configuration_error(context: &Context, errors: Vec<ConfigurationE
         return "no error".to_string();
     };
 
-    if errors
-        .iter()
-        .all(|e| e.msg.to_lowercase().contains("could not resolve"))
-    {
+    if errors.iter().all(|e| {
+        e.msg.to_lowercase().contains("could not resolve")
+            || e.msg
+                .to_lowercase()
+                .contains("temporary failure in name resolution")
+            || e.msg.to_lowercase().contains("name or service not known")
+    }) {
         return stock_str::error_no_network(context).await;
     }
 
@@ -678,7 +683,7 @@ mod tests {
     use crate::config::Config;
     use crate::test_utils::TestContext;
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_no_panic_on_bad_credentials() {
         let t = TestContext::new().await;
         t.set_config(Config::Addr, Some("probably@unexistant.addr"))

src/configure/read_url.rs

@@ -1,7 +1,6 @@
-use crate::context::Context;
+use anyhow::{anyhow, format_err};
 
-use anyhow::format_err;
-use anyhow::Context as _;
+use crate::context::Context;
 
 pub async fn read_url(context: &Context, url: &str) -> anyhow::Result<String> {
     match read_url_inner(context, url).await {
@@ -16,24 +15,27 @@ pub async fn read_url(context: &Context, url: &str) -> anyhow::Result<String> {
     }
 }
 
-pub async fn read_url_inner(context: &Context, mut url: &str) -> anyhow::Result<String> {
-    let mut _temp; // For the borrow checker
+pub async fn read_url_inner(context: &Context, url: &str) -> anyhow::Result<String> {
+    let client = reqwest::Client::new();
+    let mut url = url.to_string();
 
     // Follow up to 10 http-redirects
     for _i in 0..10 {
-        let mut response = surf::get(url).send().await.map_err(|e| e.into_inner())?;
+        let response = client.get(&url).send().await?;
         if response.status().is_redirection() {
-            _temp = response
-                .header("location")
-                .context("Redirection doesn't have a target location")?
+            let headers = response.headers();
+            let header = headers
+                .get_all("location")
+                .iter()
                 .last()
-                .to_string();
-            info!(context, "Following redirect to {}", _temp);
-            url = &_temp;
+                .ok_or_else(|| anyhow!("Redirection doesn't have a target location"))?
+                .to_str()?;
+            info!(context, "Following redirect to {}", header);
+            url = header.to_string();
             continue;
         }
 
-        return response.body_string().await.map_err(|e| e.into_inner());
+        return response.text().await.map_err(Into::into);
     }
 
     Err(format_err!("Followed 10 redirections"))

src/contact.rs

@@ -2,9 +2,9 @@
 
 use std::convert::{TryFrom, TryInto};
 use std::fmt;
+use std::path::PathBuf;
 
 use anyhow::{bail, ensure, Context as _, Result};
-use async_std::path::PathBuf;
 use deltachat_derive::{FromSql, ToSql};
 use once_cell::sync::Lazy;
 use regex::Regex;
@@ -16,7 +16,6 @@ use crate::color::str_to_color;
 use crate::config::Config;
 use crate::constants::{Blocked, Chattype, DC_GCL_ADD_SELF, DC_GCL_VERIFIED_ONLY};
 use crate::context::Context;
-use crate::dc_tools::{dc_get_abs_path, improve_single_line_input, EmailAddress};
 use crate::events::EventType;
 use crate::key::{DcKey, SignedPublicKey};
 use crate::login_param::LoginParam;
@@ -25,6 +24,7 @@ use crate::mimeparser::AvatarAction;
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateVerifiedStatus};
 use crate::sql::{self, params_iter};
+use crate::tools::{get_abs_path, improve_single_line_input, EmailAddress};
 use crate::{chat, stock_str};
 
 /// Contact ID, including reserved IDs.
@@ -38,7 +38,7 @@ impl ContactId {
     pub const UNDEFINED: ContactId = ContactId::new(0);
     /// The owner of the account.
     ///
-    /// The email-address is set by `dc_set_config` using "addr".
+    /// The email-address is set by `set_config` using "addr".
     pub const SELF: ContactId = ContactId::new(1);
     pub const INFO: ContactId = ContactId::new(2);
     pub const DEVICE: ContactId = ContactId::new(5);
@@ -142,7 +142,7 @@ pub struct Contact {
     /// E-Mail-Address of the contact. It is recommended to use `Contact::get_addr` to access this field.
     addr: String,
 
-    /// Blocked state. Use dc_contact_is_blocked to access this field.
+    /// Blocked state. Use contact_is_blocked to access this field.
     pub blocked: bool,
 
     /// Time when the contact was seen last time, Unix time in seconds.
@@ -212,13 +212,13 @@ pub enum Origin {
     /// address is in our address book
     AddressBook = 0x80000,
 
-    /// set on Alice's side for contacts like Bob that have scanned the QR code offered by her. Only means the contact has once been established using the "securejoin" procedure in the past, getting the current key verification status requires calling dc_contact_is_verified() !
+    /// set on Alice's side for contacts like Bob that have scanned the QR code offered by her. Only means the contact has once been established using the "securejoin" procedure in the past, getting the current key verification status requires calling contact_is_verified() !
     SecurejoinInvited = 0x0100_0000,
 
-    /// set on Bob's side for contacts scanned and verified from a QR code. Only means the contact has once been established using the "securejoin" procedure in the past, getting the current key verification status requires calling dc_contact_is_verified() !
+    /// set on Bob's side for contacts scanned and verified from a QR code. Only means the contact has once been established using the "securejoin" procedure in the past, getting the current key verification status requires calling contact_is_verified() !
     SecurejoinJoined = 0x0200_0000,
 
-    /// contact added mannually by dc_create_contact(), this should be the largest origin as otherwise the user cannot modify the names
+    /// contact added mannually by create_contact(), this should be the largest origin as otherwise the user cannot modify the names
     ManuallyCreated = 0x0400_0000,
 }
 
@@ -344,7 +344,7 @@ impl Contact {
     /// We assume, the contact name, if any, is entered by the user and is used "as is" therefore,
     /// normalize() is *not* called for the name. If the contact is blocked, it is unblocked.
     ///
-    /// To add a number of contacts, see `dc_add_address_book()` which is much faster for adding
+    /// To add a number of contacts, see `add_address_book()` which is much faster for adding
     /// a bunch of addresses.
     ///
     /// May result in a `#DC_EVENT_CONTACTS_CHANGED` event.
@@ -384,10 +384,10 @@ impl Contact {
 
     /// Check if an e-mail address belongs to a known and unblocked contact.
     ///
-    /// Known and unblocked contacts will be returned by `dc_get_contacts()`.
+    /// Known and unblocked contacts will be returned by `get_contacts()`.
     ///
     /// To validate an e-mail address independently of the contact database
-    /// use `dc_may_be_valid_addr()`.
+    /// use `may_be_valid_addr()`.
     pub async fn lookup_id_by_addr(
         context: &Context,
         addr: &str,
@@ -676,7 +676,7 @@ impl Contact {
 
     /// Returns known and unblocked contacts.
     ///
-    /// To get information about a single contact, see dc_get_contact().
+    /// To get information about a single contact, see get_contact().
     ///
     /// `listflags` is a combination of flags:
     /// - if the flag DC_GCL_ADD_SELF is set, SELF is added to the list unless filtered by other parameters
@@ -970,11 +970,11 @@ impl Contact {
         bail!("Could not delete contact with ongoing chats");
     }
 
-    /// Get a single contact object.  For a list, see eg. dc_get_contacts().
+    /// Get a single contact object.  For a list, see eg. get_contacts().
     ///
     /// For contact ContactId::SELF (1), the function returns sth.
     /// like "Me" in the selected language and the email address
-    /// defined by dc_set_config().
+    /// defined by set_config().
     pub async fn get_by_id(context: &Context, contact_id: ContactId) -> Result<Contact> {
         let contact = Contact::load_from_db(context, contact_id).await?;
 
@@ -1063,7 +1063,7 @@ impl Contact {
 
     /// Get the contact's profile image.
     /// This is the image set by each remote user on their own
-    /// using dc_set_config(context, "selfavatar", image).
+    /// using set_config(context, "selfavatar", image).
     pub async fn get_profile_image(&self, context: &Context) -> Result<Option<PathBuf>> {
         if self.id == ContactId::SELF {
             if let Some(p) = context.get_config(Config::Selfavatar).await? {
@@ -1071,7 +1071,7 @@ impl Contact {
             }
         } else if let Some(image_rel) = self.param.get(Param::ProfileImage) {
             if !image_rel.is_empty() {
-                return Ok(Some(dc_get_abs_path(context, image_rel)));
+                return Ok(Some(get_abs_path(context, image_rel)));
             }
         }
         Ok(None)
@@ -1438,15 +1438,12 @@ fn split_address_book(book: &str) -> Vec<(&str, &str)> {
 
 #[cfg(test)]
 mod tests {
-    use async_std::fs::File;
-    use async_std::io::WriteExt;
-
     use super::*;
 
     use crate::chat::{get_chat_contacts, send_text_msg, Chat};
     use crate::chatlist::Chatlist;
-    use crate::dc_receive_imf::dc_receive_imf;
     use crate::message::Message;
+    use crate::receive_imf::receive_imf;
     use crate::test_utils::{self, TestContext};
 
     #[test]
@@ -1508,7 +1505,7 @@ mod tests {
         )
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_contacts() -> Result<()> {
         let context = TestContext::new().await;
 
@@ -1572,7 +1569,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_is_self_addr() -> Result<()> {
         let t = TestContext::new().await;
         assert_eq!(t.is_self_addr("me@me.org").await?, false);
@@ -1584,7 +1581,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_add_or_lookup() {
         // add some contacts, this also tests add_address_book()
         let t = TestContext::new().await;
@@ -1685,12 +1682,12 @@ mod tests {
         assert!(!contact.is_blocked());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_contact_name_changes() -> Result<()> {
         let t = TestContext::new_alice().await;
 
         // first message creates contact and one-to-one-chat without name set
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: f@example.org\n\
                  To: alice@example.org\n\
@@ -1719,7 +1716,7 @@ mod tests {
         assert_eq!(contacts.len(), 1);
 
         // second message inits the name
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: Flobbyfoo <f@example.org>\n\
                  To: alice@example.org\n\
@@ -1747,7 +1744,7 @@ mod tests {
         assert_eq!(contacts.len(), 1);
 
         // third message changes the name
-        dc_receive_imf(
+        receive_imf(
             &t,
             b"From: Foo Flobby <f@example.org>\n\
                  To: alice@example.org\n\
@@ -1797,7 +1794,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_delete() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
@@ -1825,7 +1822,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_remote_authnames() {
         let t = TestContext::new().await;
 
@@ -1876,7 +1873,7 @@ mod tests {
         assert_eq!(contact.get_display_name(), "bob3");
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_remote_authnames_create_empty() {
         let t = TestContext::new().await;
 
@@ -1925,7 +1922,7 @@ mod tests {
     ///
     /// In the past, "Not Bob" name was stuck until "Bob" changed the name to "Not Bob" and back in
     /// the "From:" field or user set the name to empty string manually.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_remote_authnames_update_to() -> Result<()> {
         let t = TestContext::new().await;
 
@@ -1958,7 +1955,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_remote_authnames_edit_empty() {
         let t = TestContext::new().await;
 
@@ -1995,7 +1992,7 @@ mod tests {
         assert!(addr_cmp(" mailto:AA@AA.ORG", "Aa@Aa.orG"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_name_in_address() {
         let t = TestContext::new().await;
 
@@ -2034,7 +2031,7 @@ mod tests {
             .is_err());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_lookup_id_by_addr() {
         let t = TestContext::new().await;
 
@@ -2059,7 +2056,7 @@ mod tests {
         assert_eq!(id, Some(ContactId::SELF));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_contact_get_color() -> Result<()> {
         let t = TestContext::new().await;
         let contact_id = Contact::create(&t, "name", "name@example.net").await?;
@@ -2078,7 +2075,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_contact_get_encrinfo() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
@@ -2123,7 +2120,7 @@ CCCB 5AA9 F6E1 141C 9431
 
     /// Tests that status is synchronized when sending encrypted BCC-self messages and not
     /// synchronized when the message is not encrypted.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_synchronize_status() -> Result<()> {
         // Alice has two devices.
         let alice1 = TestContext::new_alice().await;
@@ -2188,7 +2185,7 @@ CCCB 5AA9 F6E1 141C 9431
     }
 
     /// Tests that DC_EVENT_SELFAVATAR_CHANGED is emitted on avatar changes.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_selfavatar_changed_event() -> Result<()> {
         // Alice has two devices.
         let alice1 = TestContext::new_alice().await;
@@ -2200,10 +2197,7 @@ CCCB 5AA9 F6E1 141C 9431
         assert_eq!(alice1.get_config(Config::Selfavatar).await?, None);
 
         let avatar_src = alice1.get_blobdir().join("avatar.png");
-        File::create(&avatar_src)
-            .await?
-            .write_all(test_utils::AVATAR_900x900_BYTES)
-            .await?;
+        tokio::fs::write(&avatar_src, test_utils::AVATAR_900x900_BYTES).await?;
 
         alice1
             .set_config(Config::Selfavatar, Some(avatar_src.to_str().unwrap()))
@@ -2247,7 +2241,7 @@ CCCB 5AA9 F6E1 141C 9431
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_last_seen() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
@@ -2266,7 +2260,7 @@ Chat-Version: 1.0
 Date: Sun, 22 Mar 2020 22:37:55 +0000
 
 Hi."#;
-        dc_receive_imf(&alice, mime, false).await?;
+        receive_imf(&alice, mime, false).await?;
         let msg = alice.get_last_msg().await;
 
         let timestamp = msg.get_timestamp();

src/context.rs

@@ -3,20 +3,18 @@
 use std::collections::{BTreeMap, HashMap};
 use std::ffi::OsString;
 use std::ops::Deref;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
 use anyhow::{ensure, Result};
-use async_std::{
-    channel::{self, Receiver, Sender},
-    path::{Path, PathBuf},
-    sync::{Arc, Mutex, RwLock},
-};
+use async_channel::{self as channel, Receiver, Sender};
+use tokio::sync::{Mutex, RwLock};
 
 use crate::chat::{get_chat_cnt, ChatId};
 use crate::config::Config;
 use crate::constants::DC_VERSION_STR;
 use crate::contact::Contact;
-use crate::dc_tools::{duration_to_str, time};
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::key::{DcKey, SignedPublicKey};
 use crate::login_param::LoginParam;
@@ -25,6 +23,7 @@ use crate::quota::QuotaInfo;
 use crate::ratelimit::Ratelimit;
 use crate::scheduler::Scheduler;
 use crate::sql::Sql;
+use crate::tools::{duration_to_str, time};
 
 #[derive(Clone, Debug)]
 pub struct Context {
@@ -62,6 +61,11 @@ pub struct InnerContext {
     /// Set to `None` if quota was never tried to load.
     pub(crate) quota: RwLock<Option<QuotaInfo>>,
 
+    /// Server ID response if ID capability is supported
+    /// and the server returned non-NIL on the inbox connection.
+    /// <https://datatracker.ietf.org/doc/html/rfc2971>
+    pub(crate) server_id: RwLock<Option<HashMap<String, String>>>,
+
     pub(crate) last_full_folder_scan: Mutex<Option<Instant>>,
 
     /// ID for this `Context` in the current process.
@@ -75,7 +79,7 @@ pub struct InnerContext {
     /// The text of the last error logged and emitted as an event.
     /// If the ui wants to display an error after a failure,
     /// `last_error` should be used to avoid races with the event thread.
-    pub(crate) last_error: RwLock<String>,
+    pub(crate) last_error: std::sync::RwLock<String>,
 }
 
 /// The state of ongoing process.
@@ -115,7 +119,7 @@ pub fn get_info() -> BTreeMap<&'static str, String> {
 
 impl Context {
     /// Creates new context and opens the database.
-    pub async fn new(dbfile: PathBuf, id: u32, events: Events) -> Result<Context> {
+    pub async fn new(dbfile: &Path, id: u32, events: Events) -> Result<Context> {
         let context = Self::new_closed(dbfile, id, events).await?;
 
         // Open the database if is not encrypted.
@@ -126,15 +130,15 @@ impl Context {
     }
 
     /// Creates new context without opening the database.
-    pub async fn new_closed(dbfile: PathBuf, id: u32, events: Events) -> Result<Context> {
+    pub async fn new_closed(dbfile: &Path, id: u32, events: Events) -> Result<Context> {
         let mut blob_fname = OsString::new();
         blob_fname.push(dbfile.file_name().unwrap_or_default());
         blob_fname.push("-blobs");
         let blobdir = dbfile.with_file_name(blob_fname);
-        if !blobdir.exists().await {
-            async_std::fs::create_dir_all(&blobdir).await?;
+        if !blobdir.exists() {
+            tokio::fs::create_dir_all(&blobdir).await?;
         }
-        let context = Context::with_blobdir(dbfile, blobdir, id, events).await?;
+        let context = Context::with_blobdir(dbfile.into(), blobdir, id, events).await?;
         Ok(context)
     }
 
@@ -172,7 +176,7 @@ impl Context {
         events: Events,
     ) -> Result<Context> {
         ensure!(
-            blobdir.is_dir().await,
+            blobdir.is_dir(),
             "Blobdir does not exist: {}",
             blobdir.display()
         );
@@ -189,11 +193,12 @@ impl Context {
             translated_stockstrings: RwLock::new(HashMap::new()),
             events,
             scheduler: RwLock::new(None),
-            ratelimit: RwLock::new(Ratelimit::new(Duration::new(60, 0), 3.0)), // Allow to send 3 messages immediately, no more than once every 20 seconds.
+            ratelimit: RwLock::new(Ratelimit::new(Duration::new(60, 0), 6.0)), // Allow to send 6 messages immediately, no more than once every 10 seconds.
             quota: RwLock::new(None),
+            server_id: RwLock::new(None),
             creation_time: std::time::SystemTime::now(),
             last_full_folder_scan: Mutex::new(None),
-            last_error: RwLock::new("".to_string()),
+            last_error: std::sync::RwLock::new("".to_string()),
         };
 
         let ctx = Context {
@@ -430,6 +435,11 @@ impl Context {
         res.insert("socks5_enabled", socks5_enabled.to_string());
         res.insert("entered_account_settings", l.to_string());
         res.insert("used_account_settings", l2.to_string());
+
+        let server_id = self.server_id.read().await;
+        res.insert("imap_server_id", format!("{:?}", server_id));
+        drop(server_id);
+
         res.insert("secondary_addrs", secondary_addrs);
         res.insert(
             "fetch_existing_msgs",
@@ -643,14 +653,14 @@ impl Context {
         Ok(mvbox.as_deref() == Some(folder_name))
     }
 
-    pub(crate) fn derive_blobdir(dbfile: &PathBuf) -> PathBuf {
+    pub(crate) fn derive_blobdir(dbfile: &Path) -> PathBuf {
         let mut blob_fname = OsString::new();
         blob_fname.push(dbfile.file_name().unwrap_or_default());
         blob_fname.push("-blobs");
         dbfile.with_file_name(blob_fname)
     }
 
-    pub(crate) fn derive_walfile(dbfile: &PathBuf) -> PathBuf {
+    pub(crate) fn derive_walfile(dbfile: &Path) -> PathBuf {
         let mut wal_fname = OsString::new();
         wal_fname.push(dbfile.file_name().unwrap_or_default());
         wal_fname.push("-wal");
@@ -670,28 +680,28 @@ mod tests {
         get_chat_contacts, get_chat_msgs, send_msg, set_muted, Chat, ChatId, MuteDuration,
     };
     use crate::contact::ContactId;
-    use crate::dc_receive_imf::dc_receive_imf;
-    use crate::dc_tools::dc_create_outgoing_rfc724_mid;
     use crate::message::{Message, Viewtype};
+    use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
+    use crate::tools::create_outgoing_rfc724_mid;
     use anyhow::Context as _;
     use std::time::Duration;
     use strum::IntoEnumIterator;
     use tempfile::tempdir;
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_wrong_db() -> Result<()> {
         let tmp = tempfile::tempdir()?;
         let dbfile = tmp.path().join("db.sqlite");
-        std::fs::write(&dbfile, b"123")?;
-        let res = Context::new(dbfile.into(), 1, Events::new()).await?;
+        tokio::fs::write(&dbfile, b"123").await?;
+        let res = Context::new(&dbfile, 1, Events::new()).await?;
 
         // Broken database is indistinguishable from encrypted one.
         assert_eq!(res.is_open().await, false);
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_fresh_msgs() {
         let t = TestContext::new().await;
         let fresh = t.get_fresh_msgs().await.unwrap();
@@ -712,13 +722,13 @@ mod tests {
              \n\
              hello\n",
             contact.get_addr(),
-            dc_create_outgoing_rfc724_mid(None, contact.get_addr())
+            create_outgoing_rfc724_mid(None, contact.get_addr())
         );
         println!("{}", msg);
-        dc_receive_imf(t, msg.as_bytes(), false).await.unwrap();
+        receive_imf(t, msg.as_bytes(), false).await.unwrap();
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_fresh_msgs_and_muted_chats() {
         // receive various mails in 3 chats
         let t = TestContext::new_alice().await;
@@ -768,7 +778,7 @@ mod tests {
         assert_eq!(t.get_fresh_msgs().await.unwrap().len(), 9); // claire is counted again
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_fresh_msgs_and_muted_until() {
         let t = TestContext::new_alice().await;
         let bob = t.create_chat_with_contact("", "bob@g.it").await;
@@ -826,61 +836,61 @@ mod tests {
         assert_eq!(t.get_fresh_msgs().await.unwrap().len(), 1);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_blobdir_exists() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
-        Context::new(dbfile.into(), 1, Events::new()).await.unwrap();
+        Context::new(&dbfile, 1, Events::new()).await.unwrap();
         let blobdir = tmp.path().join("db.sqlite-blobs");
         assert!(blobdir.is_dir());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_wrong_blogdir() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
         let blobdir = tmp.path().join("db.sqlite-blobs");
-        std::fs::write(&blobdir, b"123").unwrap();
-        let res = Context::new(dbfile.into(), 1, Events::new()).await;
+        tokio::fs::write(&blobdir, b"123").await.unwrap();
+        let res = Context::new(&dbfile, 1, Events::new()).await;
         assert!(res.is_err());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sqlite_parent_not_exists() {
         let tmp = tempfile::tempdir().unwrap();
         let subdir = tmp.path().join("subdir");
         let dbfile = subdir.join("db.sqlite");
         let dbfile2 = dbfile.clone();
-        Context::new(dbfile.into(), 1, Events::new()).await.unwrap();
+        Context::new(&dbfile, 1, Events::new()).await.unwrap();
         assert!(subdir.is_dir());
         assert!(dbfile2.is_file());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_with_empty_blobdir() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
         let blobdir = PathBuf::new();
-        let res = Context::with_blobdir(dbfile.into(), blobdir, 1, Events::new()).await;
+        let res = Context::with_blobdir(dbfile, blobdir, 1, Events::new()).await;
         assert!(res.is_err());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_with_blobdir_not_exists() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
         let blobdir = tmp.path().join("blobs");
-        let res = Context::with_blobdir(dbfile.into(), blobdir.into(), 1, Events::new()).await;
+        let res = Context::with_blobdir(dbfile, blobdir, 1, Events::new()).await;
         assert!(res.is_err());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn no_crashes_on_context_deref() {
         let t = TestContext::new().await;
         std::mem::drop(t);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_info() {
         let t = TestContext::new().await;
 
@@ -896,7 +906,7 @@ mod tests {
         assert_eq!(info.get("level").unwrap(), "awesome");
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_info_completeness() {
         // For easier debugging,
         // get_info() shall return all important information configurable by the Config-values.
@@ -944,7 +954,7 @@ mod tests {
         }
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_msgs() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let self_talk = ChatId::create_for_contact(&alice, ContactId::SELF).await?;
@@ -1000,7 +1010,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_limit_search_msgs() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let chat = alice
@@ -1033,13 +1043,13 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_check_passphrase() -> Result<()> {
         let dir = tempdir()?;
         let dbfile = dir.path().join("db.sqlite");
 
         let id = 1;
-        let context = Context::new_closed(dbfile.clone().into(), id, Events::new())
+        let context = Context::new_closed(&dbfile, id, Events::new())
             .await
             .context("failed to create context")?;
         assert_eq!(context.open("foo".to_string()).await?, true);
@@ -1047,7 +1057,7 @@ mod tests {
         drop(context);
 
         let id = 2;
-        let context = Context::new(dbfile.into(), id, Events::new())
+        let context = Context::new(&dbfile, id, Events::new())
             .await
             .context("failed to create context")?;
         assert_eq!(context.is_open().await, false);
@@ -1058,7 +1068,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ongoing() -> Result<()> {
         let context = TestContext::new().await;
 

src/dehtml.rs

@@ -382,7 +382,7 @@ mod tests {
         assert_eq!(txt.trim(), "two\nlines");
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_quote_div() {
         let input = include_str!("../test-data/message/gmx-quote-body.eml");
         let dehtml = dehtml(input).unwrap();

src/download.rs

@@ -7,12 +7,12 @@ use std::collections::BTreeMap;
 
 use crate::config::Config;
 use crate::context::Context;
-use crate::dc_tools::time;
 use crate::imap::{Imap, ImapActionResult};
 use crate::job::{self, Action, Job, Status};
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, Part};
 use crate::param::Params;
+use crate::tools::time;
 use crate::{job_try, stock_str, EventType};
 use std::cmp::max;
 
@@ -257,9 +257,9 @@ mod tests {
     use num_traits::FromPrimitive;
 
     use crate::chat::send_msg;
-    use crate::dc_receive_imf::dc_receive_imf_inner;
     use crate::ephemeral::Timer;
     use crate::message::Viewtype;
+    use crate::receive_imf::receive_imf_inner;
     use crate::test_utils::TestContext;
 
     use super::*;
@@ -280,7 +280,7 @@ mod tests {
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_download_limit() -> Result<()> {
         let t = TestContext::new_alice().await;
 
@@ -303,7 +303,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_update_download_state() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat = t.create_chat_with_contact("Bob", "bob@example.org").await;
@@ -328,7 +328,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_partial_receive_imf() -> Result<()> {
         let t = TestContext::new_alice().await;
 
@@ -342,7 +342,7 @@ mod tests {
              Date: Sun, 22 Mar 2020 22:37:57 +0000\
              Content-Type: text/plain";
 
-        dc_receive_imf_inner(
+        receive_imf_inner(
             &t,
             "Mr.12345678901@example.com",
             header.as_bytes(),
@@ -359,7 +359,7 @@ mod tests {
             .unwrap()
             .contains(&stock_str::partial_download_msg_body(&t, 100000).await));
 
-        dc_receive_imf_inner(
+        receive_imf_inner(
             &t,
             "Mr.12345678901@example.com",
             format!("{}\n\n100k text...", header).as_bytes(),
@@ -376,7 +376,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_partial_download_and_ephemeral() -> Result<()> {
         let t = TestContext::new_alice().await;
         let chat_id = t
@@ -388,7 +388,7 @@ mod tests {
             .await?;
 
         // download message from bob partially, this must not change the ephemeral timer
-        dc_receive_imf_inner(
+        receive_imf_inner(
             &t,
             "first@example.org",
             b"From: Bob <bob@example.org>\n\

src/e2ee.rs

@@ -8,11 +8,13 @@ use num_traits::FromPrimitive;
 
 use crate::aheader::{Aheader, EncryptPreference};
 use crate::config::Config;
+use crate::contact::addr_cmp;
 use crate::context::Context;
 use crate::headerdef::HeaderDef;
 use crate::headerdef::HeaderDefMap;
 use crate::key::{DcKey, Fingerprint, SignedPublicKey, SignedSecretKey};
 use crate::keyring::Keyring;
+use crate::log::LogExt;
 use crate::peerstate::{Peerstate, PeerstateVerifiedStatus};
 use crate::pgp;
 
@@ -131,6 +133,56 @@ impl EncryptHelper {
     }
 }
 
+/// Applies Autocrypt header to Autocrypt peer state and saves it into the database.
+///
+/// If we already know this fingerprint from another contact's peerstate, return that
+/// peerstate in order to make AEAP work, but don't save it into the db yet.
+///
+/// Returns updated peerstate.
+pub(crate) async fn get_autocrypt_peerstate(
+    context: &Context,
+    from: &str,
+    autocrypt_header: Option<&Aheader>,
+    message_time: i64,
+) -> Result<Option<Peerstate>> {
+    let mut peerstate;
+
+    // Apply Autocrypt header
+    if let Some(header) = autocrypt_header {
+        // The "from_nongossiped_fingerprint" part is for AEAP:
+        // If we know this fingerprint from another addr,
+        // we may want to do a transition from this other addr
+        // (and keep its peerstate)
+        peerstate = Peerstate::from_nongossiped_fingerprint_or_addr(
+            context,
+            &header.public_key.fingerprint(),
+            from,
+        )
+        .await?;
+
+        if let Some(ref mut peerstate) = peerstate {
+            if addr_cmp(&peerstate.addr, from) {
+                peerstate.apply_header(header, message_time);
+                peerstate.save_to_db(&context.sql, false).await?;
+            }
+            // If `peerstate.addr` and `from` differ, this means that
+            // someone is using the same key but a different addr, probably
+            // because they made an AEAP transition.
+            // But we don't know if that's legit until we checked the
+            // signatures, so wait until then with writing anything
+            // to the database.
+        } else {
+            let p = Peerstate::from_header(header, message_time);
+            p.save_to_db(&context.sql, true).await?;
+            peerstate = Some(p);
+        }
+    } else {
+        peerstate = Peerstate::from_addr(context, from).await?;
+    }
+
+    Ok(peerstate)
+}
+
 /// Tries to decrypt a message, but only if it is structured as an
 /// Autocrypt message.
 ///
@@ -140,10 +192,42 @@ impl EncryptHelper {
 /// If the message is wrongly signed, this will still return the decrypted
 /// message but the HashSet will be empty.
 pub async fn try_decrypt(
+    context: &Context,
+    mail: &ParsedMail<'_>,
+    decryption_info: &DecryptionInfo,
+) -> Result<Option<(Vec<u8>, HashSet<Fingerprint>)>> {
+    // Possibly perform decryption
+    let public_keyring_for_validate = keyring_from_peerstate(&decryption_info.peerstate);
+
+    let context = context;
+    let encrypted_data_part = match get_autocrypt_mime(mail)
+        .or_else(|| get_mixed_up_mime(mail))
+        .or_else(|| get_attachment_mime(mail))
+    {
+        None => {
+            // not an autocrypt mime message, abort and ignore
+            return Ok(None);
+        }
+        Some(res) => res,
+    };
+    info!(context, "Detected Autocrypt-mime message");
+    let private_keyring: Keyring<SignedSecretKey> = Keyring::new_self(context)
+        .await
+        .context("failed to get own keyring")?;
+
+    decrypt_part(
+        encrypted_data_part,
+        private_keyring,
+        public_keyring_for_validate,
+    )
+    .await
+}
+
+pub async fn create_decryption_info(
     context: &Context,
     mail: &ParsedMail<'_>,
     message_time: i64,
-) -> Result<(Option<Vec<u8>>, HashSet<Fingerprint>)> {
+) -> Result<DecryptionInfo> {
     let from = mail
         .headers
         .get_header(HeaderDef::From_)
@@ -152,56 +236,34 @@ pub async fn try_decrypt(
         .map(|from| from.addr)
         .unwrap_or_default();
 
-    let mut peerstate = Peerstate::from_addr(context, &from).await?;
+    let autocrypt_header = Aheader::from_headers(&from, &mail.headers)
+        .ok_or_log_msg(context, "Failed to parse Autocrypt header")
+        .flatten();
 
-    // Apply Autocrypt header
-    match Aheader::from_headers(&from, &mail.headers) {
-        Ok(Some(ref header)) => {
-            if let Some(ref mut peerstate) = peerstate {
-                peerstate.apply_header(header, message_time);
-                peerstate.save_to_db(&context.sql, false).await?;
-            } else {
-                let p = Peerstate::from_header(header, message_time);
-                p.save_to_db(&context.sql, true).await?;
-                peerstate = Some(p);
-            }
-        }
-        Ok(None) => {}
-        Err(err) => warn!(context, "Failed to parse Autocrypt header: {}", err),
-    }
+    let peerstate =
+        get_autocrypt_peerstate(context, &from, autocrypt_header.as_ref(), message_time).await?;
 
-    // Possibly perform decryption
-    let mut public_keyring_for_validate: Keyring<SignedPublicKey> = Keyring::new();
+    Ok(DecryptionInfo {
+        from,
+        autocrypt_header,
+        peerstate,
+        message_time,
+    })
+}
 
-    if let Some(ref mut peerstate) = peerstate {
-        peerstate
-            .handle_fingerprint_change(context, message_time)
-            .await?;
-        if let Some(key) = &peerstate.public_key {
-            public_keyring_for_validate.add(key.clone());
-        } else if let Some(key) = &peerstate.gossip_key {
-            public_keyring_for_validate.add(key.clone());
-        }
-    }
-
-    let (out_mail, signatures) =
-        match decrypt_if_autocrypt_message(context, mail, public_keyring_for_validate).await? {
-            Some((out_mail, signatures)) => (Some(out_mail), signatures),
-            None => (None, Default::default()),
-        };
-
-    if let Some(mut peerstate) = peerstate {
-        // If message is not encrypted and it is not a read receipt, degrade encryption.
-        if out_mail.is_none()
-            && message_time > peerstate.last_seen_autocrypt
-            && !contains_report(mail)
-        {
-            peerstate.degrade_encryption(message_time);
-            peerstate.save_to_db(&context.sql, false).await?;
-        }
-    }
-
-    Ok((out_mail, signatures))
+#[derive(Debug)]
+pub struct DecryptionInfo {
+    /// The From address. This is the address from the unnencrypted, outer
+    /// From header.
+    pub from: String,
+    pub autocrypt_header: Option<Aheader>,
+    /// The peerstate that will be used to validate the signatures
+    pub peerstate: Option<Peerstate>,
+    /// The timestamp when the message was sent.
+    /// If this is older than the peerstate's last_seen, this probably
+    /// means out-of-order message arrival, We don't modify the
+    /// peerstate in this case.
+    pub message_time: i64,
 }
 
 /// Returns a reference to the encrypted payload of a valid PGP/MIME message.
@@ -283,32 +345,16 @@ fn get_attachment_mime<'a, 'b>(mail: &'a ParsedMail<'b>) -> Option<&'a ParsedMai
     }
 }
 
-async fn decrypt_if_autocrypt_message(
-    context: &Context,
-    mail: &ParsedMail<'_>,
-    public_keyring_for_validate: Keyring<SignedPublicKey>,
-) -> Result<Option<(Vec<u8>, HashSet<Fingerprint>)>> {
-    let encrypted_data_part = match get_autocrypt_mime(mail)
-        .or_else(|| get_mixed_up_mime(mail))
-        .or_else(|| get_attachment_mime(mail))
-    {
-        None => {
-            // not an autocrypt mime message, abort and ignore
-            return Ok(None);
+fn keyring_from_peerstate(peerstate: &Option<Peerstate>) -> Keyring<SignedPublicKey> {
+    let mut public_keyring_for_validate: Keyring<SignedPublicKey> = Keyring::new();
+    if let Some(ref peerstate) = *peerstate {
+        if let Some(key) = &peerstate.public_key {
+            public_keyring_for_validate.add(key.clone());
+        } else if let Some(key) = &peerstate.gossip_key {
+            public_keyring_for_validate.add(key.clone());
         }
-        Some(res) => res,
-    };
-    info!(context, "Detected Autocrypt-mime message");
-    let private_keyring: Keyring<SignedSecretKey> = Keyring::new_self(context)
-        .await
-        .context("failed to get own keyring")?;
-
-    decrypt_part(
-        encrypted_data_part,
-        private_keyring,
-        public_keyring_for_validate,
-    )
-    .await
+    }
+    public_keyring_for_validate
 }
 
 /// Validates signatures of Multipart/Signed message part, as defined in RFC 1847.
@@ -357,7 +403,7 @@ async fn decrypt_part(
             return Ok(Some((content, valid_detached_signatures)));
         } else {
             // If the message was wrongly or not signed, still return the plain text.
-            // The caller has to check the signatures then.
+            // The caller has to check if the signatures set is empty then.
 
             return Ok(Some((plain, ret_valid_signatures)));
         }
@@ -380,18 +426,6 @@ fn has_decrypted_pgp_armor(input: &[u8]) -> bool {
     false
 }
 
-/// Checks if a MIME structure contains a multipart/report part.
-///
-/// As reports are often unencrypted, we do not reset the Autocrypt header in
-/// this case.
-///
-/// However, Delta Chat itself has no problem with encrypted multipart/report
-/// parts and MUAs should be encouraged to encrpyt multipart/reports as well so
-/// that we could use the normal Autocrypt processing.
-fn contains_report(mail: &ParsedMail<'_>) -> bool {
-    mail.ctype.mimetype == "multipart/report"
-}
-
 /// Ensures a private key exists for the configured user.
 ///
 /// Normally the private key is generated when the first message is
@@ -411,10 +445,10 @@ pub async fn ensure_secret_key_exists(context: &Context) -> Result<String> {
 #[cfg(test)]
 mod tests {
     use crate::chat;
-    use crate::dc_receive_imf::dc_receive_imf;
     use crate::message::{Message, Viewtype};
     use crate::param::Param;
     use crate::peerstate::ToSave;
+    use crate::receive_imf::receive_imf;
     use crate::test_utils::{bob_keypair, TestContext};
 
     use super::*;
@@ -422,7 +456,7 @@ mod tests {
     mod ensure_secret_key_exists {
         use super::*;
 
-        #[async_std::test]
+        #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
         async fn test_prexisting() {
             let t = TestContext::new_alice().await;
             assert_eq!(
@@ -431,7 +465,7 @@ mod tests {
             );
         }
 
-        #[async_std::test]
+        #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
         async fn test_not_configured() {
             let t = TestContext::new().await;
             assert!(ensure_secret_key_exists(&t).await.is_err());
@@ -480,7 +514,7 @@ Sent with my Delta Chat Messenger: https://delta.chat";
         assert_eq!(has_decrypted_pgp_armor(data), false);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_encrypted_no_autocrypt() -> anyhow::Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -588,7 +622,7 @@ Sent with my Delta Chat Messenger: https://delta.chat";
         vec![(Some(peerstate), addr)]
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_should_encrypt() {
         let t = TestContext::new_alice().await;
         let encrypt_helper = EncryptHelper::new(&t).await.unwrap();
@@ -615,7 +649,7 @@ Sent with my Delta Chat Messenger: https://delta.chat";
         assert!(!encrypt_helper.should_encrypt(&t, false, &ps).unwrap());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_mixed_up_mime() -> Result<()> {
         // "Mixed Up" mail as received when sending an encrypted
         // message using Delta Chat Desktop via ProtonMail IMAP/SMTP
@@ -646,7 +680,7 @@ Sent with my Delta Chat Messenger: https://delta.chat";
         assert!(get_attachment_mime(&mail).is_some());
 
         let bob = TestContext::new_bob().await;
-        dc_receive_imf(&bob, attachment_mime, false).await?;
+        receive_imf(&bob, attachment_mime, false).await?;
         let msg = bob.get_last_msg().await;
         assert_eq!(msg.text.as_deref(), Some("Hello from Thunderbird!"));
 

src/ephemeral.rs

@@ -62,15 +62,14 @@ use std::str::FromStr;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use anyhow::{ensure, Context as _, Result};
-use async_std::channel::Receiver;
-use async_std::future::timeout;
+use async_channel::Receiver;
 use serde::{Deserialize, Serialize};
+use tokio::time::timeout;
 
 use crate::chat::{send_msg, ChatId};
 use crate::constants::{DC_CHAT_ID_LAST_SPECIAL, DC_CHAT_ID_TRASH};
 use crate::contact::ContactId;
 use crate::context::Context;
-use crate::dc_tools::{duration_to_str, time};
 use crate::download::MIN_DELETE_SERVER_AFTER;
 use crate::events::EventType;
 use crate::log::LogExt;
@@ -78,6 +77,7 @@ use crate::message::{Message, MessageState, MsgId, Viewtype};
 use crate::mimeparser::SystemMessage;
 use crate::sql::{self, params_iter};
 use crate::stock_str;
+use crate::tools::{duration_to_str, time};
 use std::cmp::max;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
@@ -339,7 +339,7 @@ pub(crate) async fn delete_expired_messages(context: &Context, now: i64) -> Resu
         .sql
         .execute(
             // If you change which information is removed here, also change MsgId::trash() and
-            // which information dc_receive_imf::add_parts() still adds to the db if the chat_id is TRASH
+            // which information receive_imf::add_parts() still adds to the db if the chat_id is TRASH
             r#"
 UPDATE msgs
 SET 
@@ -572,16 +572,16 @@ pub(crate) async fn start_ephemeral_timers(context: &Context) -> Result<()> {
 mod tests {
     use super::*;
     use crate::config::Config;
-    use crate::dc_receive_imf::dc_receive_imf;
-    use crate::dc_tools::MAX_SECONDS_TO_LEND_FROM_FUTURE;
     use crate::download::DownloadState;
+    use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
+    use crate::tools::MAX_SECONDS_TO_LEND_FROM_FUTURE;
     use crate::{
         chat::{self, Chat, ChatItem},
-        dc_tools::IsNoneOrEmpty,
+        tools::IsNoneOrEmpty,
     };
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_stock_ephemeral_messages() {
         let context = TestContext::new().await;
 
@@ -711,7 +711,7 @@ mod tests {
     }
 
     /// Test enabling and disabling ephemeral timer remotely.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ephemeral_enable_disable() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -743,7 +743,7 @@ mod tests {
     }
 
     /// Test that timer is enabled even if the message explicitly enabling the timer is lost.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ephemeral_enable_lost() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -785,7 +785,7 @@ mod tests {
 
     /// Test that Alice replying to the chat without a timer at the same time as Bob enables the
     /// timer does not result in disabling the timer on the Bob's side.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ephemeral_timer_rollback() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -859,7 +859,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ephemeral_delete_msgs() -> Result<()> {
         let t = TestContext::new_alice().await;
         let self_chat = t.get_self_chat().await;
@@ -985,7 +985,7 @@ mod tests {
         }
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_delete_expired_imap_messages() -> Result<()> {
         let t = TestContext::new_alice().await;
         const HOUR: i64 = 60 * 60;
@@ -1096,12 +1096,12 @@ mod tests {
     }
 
     // Regression test for a bug in the timer rollback protection.
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_ephemeral_timer_references() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
         // Message with Message-ID <first@example.com> and no timer is received.
-        dc_receive_imf(
+        receive_imf(
             &alice,
             b"From: Bob <bob@example.com>\n\
                     To: Alice <alice@example.org>\n\
@@ -1120,7 +1120,7 @@ mod tests {
         assert_eq!(chat_id.get_ephemeral_timer(&alice).await?, Timer::Disabled);
 
         // Message with Message-ID <second@example.com> is received.
-        dc_receive_imf(
+        receive_imf(
             &alice,
             b"From: Bob <bob@example.com>\n\
                     To: Alice <alice@example.org>\n\
@@ -1155,7 +1155,7 @@ mod tests {
         //
         // The message also contains a quote of the first message to test that only References:
         // header and not In-Reply-To: is consulted by the rollback protection.
-        dc_receive_imf(
+        receive_imf(
             &alice,
             b"From: Bob <bob@example.com>\n\
                     To: Alice <alice@example.org>\n\

src/events.rs

@@ -1,7 +1,8 @@
 //! # Events specification.
 
-use async_std::channel::{self, Receiver, Sender, TrySendError};
-use async_std::path::PathBuf;
+use std::path::PathBuf;
+
+use async_channel::{self as channel, Receiver, Sender, TrySendError};
 
 use crate::chat::ChatId;
 use crate::contact::ContactId;
@@ -61,23 +62,18 @@ impl Events {
 ///
 /// [`Context`]: crate::context::Context
 /// [`Context::get_event_emitter`]: crate::context::Context::get_event_emitter
-/// [`Stream`]: async_std::stream::Stream
+/// [`Stream`]: futures::stream::Stream
 #[derive(Debug, Clone)]
 pub struct EventEmitter(Receiver<Event>);
 
 impl EventEmitter {
-    /// Blocking recv of an event. Return `None` if the `Sender` has been droped.
-    pub fn recv_sync(&self) -> Option<Event> {
-        async_std::task::block_on(self.recv())
-    }
-
     /// Async recv of an event. Return `None` if the `Sender` has been droped.
     pub async fn recv(&self) -> Option<Event> {
         self.0.recv().await.ok()
     }
 }
 
-impl async_std::stream::Stream for EventEmitter {
+impl futures::stream::Stream for EventEmitter {
     type Item = Event;
 
     fn poll_next(

src/format_flowed.rs

@@ -203,7 +203,7 @@ mod tests {
         assert_eq!(format_flowed_quote(quote), expected);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_send_quotes() -> anyhow::Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;

src/html.rs

@@ -280,11 +280,11 @@ mod tests {
     use crate::chat::forward_msgs;
     use crate::config::Config;
     use crate::contact::ContactId;
-    use crate::dc_receive_imf::dc_receive_imf;
     use crate::message::{MessengerMessage, Viewtype};
+    use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_plain_unspecified() {
         let t = TestContext::new().await;
         let raw = include_bytes!("../test-data/message/text_plain_unspecified.eml");
@@ -300,7 +300,7 @@ This message does not have Content-Type nor Subject.<br/>
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_plain_iso88591() {
         let t = TestContext::new().await;
         let raw = include_bytes!("../test-data/message/text_plain_iso88591.eml");
@@ -316,7 +316,7 @@ message with a non-UTF-8 encoding: äöüßÄÖÜ<br/>
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_plain_flowed() {
         let t = TestContext::new().await;
         let raw = include_bytes!("../test-data/message/text_plain_flowed.eml");
@@ -336,7 +336,7 @@ and will be wrapped as usual.<br/>
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_alt_plain() {
         let t = TestContext::new().await;
         let raw = include_bytes!("../test-data/message/text_alt_plain.eml");
@@ -355,7 +355,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_html() {
         let t = TestContext::new().await;
         let raw = include_bytes!("../test-data/message/text_html.eml");
@@ -373,7 +373,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_alt_html() {
         let t = TestContext::new().await;
         let raw = include_bytes!("../test-data/message/text_alt_html.eml");
@@ -388,7 +388,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_alt_plain_html() {
         let t = TestContext::new().await;
         let raw = include_bytes!("../test-data/message/text_alt_plain_html.eml");
@@ -405,7 +405,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         );
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_htmlparse_apple_cid_jpg() {
         // load raw mime html-data with related image-part (cid:)
         // and make sure, Content-Id has angle-brackets that are removed correctly.
@@ -424,14 +424,14 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         assert!(!parser.html.contains("cid:"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_html_invalid_msgid() {
         let t = TestContext::new().await;
         let msg_id = MsgId::new(100);
         assert!(msg_id.get_html(&t).await.is_err())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_html_forwarding() {
         // alice receives a non-delta html-message
         let alice = TestContext::new_alice().await;
@@ -440,7 +440,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
         let raw = include_bytes!("../test-data/message/text_alt_plain_html.eml");
-        dc_receive_imf(&alice, raw, false).await.unwrap();
+        receive_imf(&alice, raw, false).await.unwrap();
         let msg = alice.get_last_msg_in(chat.get_id()).await;
         assert_ne!(msg.get_from_id(), ContactId::SELF);
         assert_eq!(msg.is_dc_message, MessengerMessage::No);
@@ -478,7 +478,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         assert!(html.contains("this is <b>html</b>"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_html_forwarding_encrypted() {
         // Alice receives a non-delta html-message
         // (`ShowEmails=1` lets Alice actually receive non-delta messages for known contacts,
@@ -489,7 +489,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
         let raw = include_bytes!("../test-data/message/text_alt_plain_html.eml");
-        dc_receive_imf(&alice, raw, false).await.unwrap();
+        receive_imf(&alice, raw, false).await.unwrap();
         let msg = alice.get_last_msg_in(chat.get_id()).await;
 
         // forward the message to saved-messages,
@@ -515,7 +515,7 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         assert!(html.contains("this is <b>html</b>"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_set_html() {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
@@ -547,11 +547,11 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         assert!(html.contains("<b>html</b> text"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_cp1252_html() -> Result<()> {
         let t = TestContext::new_alice().await;
         t.set_config(Config::ShowEmails, Some("2")).await?;
-        dc_receive_imf(
+        receive_imf(
             &t,
             include_bytes!("../test-data/message/cp1252-html.eml"),
             false,

src/imap.rs

@@ -11,11 +11,11 @@ use std::{
 };
 
 use anyhow::{bail, format_err, Context as _, Result};
+use async_channel::Receiver;
 use async_imap::types::{
     Fetch, Flag, Mailbox, Name, NameAttribute, Quota, QuotaRoot, UnsolicitedResponse,
 };
-use async_std::channel::Receiver;
-use async_std::prelude::*;
+use futures::StreamExt;
 use num_traits::FromPrimitive;
 
 use crate::chat::{self, ChatId, ChatIdBlocked};
@@ -25,10 +25,6 @@ use crate::constants::{
 };
 use crate::contact::{normalize_name, Contact, ContactId, Modifier, Origin};
 use crate::context::Context;
-use crate::dc_receive_imf::{
-    dc_receive_imf_inner, from_field_to_contact_id, get_prefetch_parent_message, ReceivedMsg,
-};
-use crate::dc_tools::dc_create_id;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::job;
@@ -37,12 +33,16 @@ use crate::login_param::{
 };
 use crate::message::{self, Message, MessageState, MessengerMessage, MsgId, Viewtype};
 use crate::mimeparser;
-use crate::oauth2::dc_get_oauth2_access_token;
+use crate::oauth2::get_oauth2_access_token;
 use crate::provider::Socket;
+use crate::receive_imf::{
+    from_field_to_contact_id, get_prefetch_parent_message, receive_imf_inner, ReceivedMsg,
+};
 use crate::scheduler::connectivity::ConnectivityStore;
 use crate::scheduler::InterruptInfo;
 use crate::sql;
 use crate::stock_str;
+use crate::tools::create_id;
 
 mod client;
 mod idle;
@@ -390,7 +390,7 @@ impl Imap {
         let login_res = if oauth2 {
             let addr: &str = config.addr.as_ref();
 
-            let token = dc_get_oauth2_access_token(context, addr, imap_pw, true)
+            let token = get_oauth2_access_token(context, addr, imap_pw, true)
                 .await?
                 .context("IMAP could not get OAUTH token")?;
             let auth = OAuth2 {
@@ -451,7 +451,9 @@ impl Imap {
     }
 
     /// Determine server capabilities if not done yet.
-    async fn determine_capabilities(&mut self) -> Result<()> {
+    ///
+    /// If server supports ID capability, send our client ID.
+    pub(crate) async fn determine_capabilities(&mut self, context: &Context) -> Result<()> {
         if self.capabilities_determined {
             return Ok(());
         }
@@ -463,6 +465,12 @@ impl Imap {
             .capabilities()
             .await
             .context("CAPABILITY command error")?;
+        if caps.has_str("ID") {
+            let server_id = session.id([("name", Some("Delta Chat"))]).await?;
+            info!(context, "Server ID: {:?}", server_id);
+            let mut lock = context.server_id.write().await;
+            *lock = server_id;
+        }
         self.config.can_idle = caps.has_str("IDLE");
         self.config.can_move = caps.has_str("MOVE");
         self.config.can_check_quota = caps.has_str("QUOTA");
@@ -481,8 +489,8 @@ impl Imap {
             return Err(err);
         }
 
+        self.determine_capabilities(context).await?;
         self.ensure_configured_folders(context, true).await?;
-        self.determine_capabilities().await?;
         Ok(())
     }
 
@@ -787,7 +795,7 @@ impl Imap {
             };
 
             // Get the Message-ID or generate a fake one to identify the message in the database.
-            let message_id = prefetch_get_message_id(&headers).unwrap_or_else(dc_create_id);
+            let message_id = prefetch_get_message_id(&headers).unwrap_or_else(create_id);
 
             let target = match target_folder(context, folder, is_spam_folder, &headers).await? {
                 Some(config) => match context.get_config(config).await? {
@@ -875,8 +883,8 @@ impl Imap {
         received_msgs.extend(received_msgs_2);
 
         // determine which uid_next to use to update to
-        // dc_receive_imf() returns an `Err` value only on recoverable errors, otherwise it just logs an error.
-        // `largest_uid_processed` is the largest uid where dc_receive_imf() did NOT return an error.
+        // receive_imf() returns an `Err` value only on recoverable errors, otherwise it just logs an error.
+        // `largest_uid_processed` is the largest uid where receive_imf() did NOT return an error.
 
         // So: Update the uid_next to the largest uid that did NOT recoverably fail. Not perfect because if there was
         // another message afterwards that succeeded, we will not retry. The upside is that we will not retry an infinite amount of times.
@@ -1431,7 +1439,7 @@ impl Imap {
                     continue;
                 }
 
-                // XXX put flags into a set and pass them to dc_receive_imf
+                // XXX put flags into a set and pass them to receive_imf
                 let context = context.clone();
 
                 // safe, as we checked above that there is a body.
@@ -1449,7 +1457,7 @@ impl Imap {
                     );
                     ""
                 };
-                match dc_receive_imf_inner(
+                match receive_imf_inner(
                     &context,
                     rfc724_mid,
                     body,
@@ -1466,7 +1474,7 @@ impl Imap {
                         last_uid = Some(server_uid)
                     }
                     Err(err) => {
-                        warn!(context, "dc_receive_imf error: {:#}", err);
+                        warn!(context, "receive_imf error: {:#}", err);
                     }
                 };
             }
@@ -1561,6 +1569,59 @@ impl Imap {
         self.configure_folders(context, create_mvbox).await
     }
 
+    /// Attempts to configure mvbox.
+    ///
+    /// Tries to find any folder in the given list of `folders`. If none is found, tries to create
+    /// any of them in the same order. This method does not use LIST command to ensure that
+    /// configuration works even if mailbox lookup is forbidden via Access Control List (see
+    /// <https://datatracker.ietf.org/doc/html/rfc4314>).
+    ///
+    /// Returns first found or created folder name.
+    async fn configure_mvbox<'a>(
+        &mut self,
+        context: &Context,
+        folders: &[&'a str],
+        create_mvbox: bool,
+    ) -> Result<Option<&'a str>> {
+        // Close currently selected folder if needed.
+        // We are going to select folders using low-level EXAMINE operations below.
+        self.select_folder(context, None).await?;
+
+        let session = self
+            .session
+            .as_mut()
+            .context("no IMAP connection established")?;
+
+        for folder in folders {
+            info!(context, "Looking for MVBOX-folder \"{}\"...", &folder);
+            let res = session.examine(&folder).await;
+            if res.is_ok() {
+                info!(
+                    context,
+                    "MVBOX-folder {:?} successfully selected, using it.", &folder
+                );
+                session.close().await?;
+                return Ok(Some(folder));
+            }
+        }
+
+        if create_mvbox {
+            for folder in folders {
+                match session.create(&folder).await {
+                    Ok(_) => {
+                        info!(context, "MVBOX-folder {} created.", &folder);
+                        return Ok(Some(folder));
+                    }
+                    Err(err) => {
+                        warn!(context, "Cannot create MVBOX-folder {:?}: {}", &folder, err);
+                    }
+                }
+            }
+        }
+
+        Ok(None)
+    }
+
     pub async fn configure_folders(&mut self, context: &Context, create_mvbox: bool) -> Result<()> {
         let session = self
             .session
@@ -1573,9 +1634,7 @@ impl Imap {
             .context("list_folders failed")?;
         let mut delimiter = ".".to_string();
         let mut delimiter_is_default = true;
-        let mut mvbox_folder = None;
         let mut folder_configs = BTreeMap::new();
-        let mut fallback_folder = get_fallback_folder(&delimiter);
 
         while let Some(folder) = folders.next().await {
             let folder = folder?;
@@ -1585,22 +1644,13 @@ impl Imap {
             if let Some(d) = folder.delimiter() {
                 if delimiter_is_default && !d.is_empty() && delimiter != d {
                     delimiter = d.to_string();
-                    fallback_folder = get_fallback_folder(&delimiter);
                     delimiter_is_default = false;
                 }
             }
 
             let folder_meaning = get_folder_meaning(&folder);
             let folder_name_meaning = get_folder_meaning_by_name(folder.name());
-            if folder.name() == "DeltaChat" {
-                // Always takes precedence
-                mvbox_folder = Some(folder.name().to_string());
-            } else if folder.name() == fallback_folder {
-                // only set if none has been already set
-                if mvbox_folder.is_none() {
-                    mvbox_folder = Some(folder.name().to_string());
-                }
-            } else if let Some(config) = folder_meaning.to_config() {
+            if let Some(config) = folder_meaning.to_config() {
                 // Always takes precedence
                 folder_configs.insert(config, folder.name().to_string());
             } else if let Some(config) = folder_name_meaning.to_config() {
@@ -1614,47 +1664,17 @@ impl Imap {
 
         info!(context, "Using \"{}\" as folder-delimiter.", delimiter);
 
-        if mvbox_folder.is_none() && create_mvbox {
-            info!(context, "Creating MVBOX-folder \"DeltaChat\"...",);
+        let fallback_folder = format!("INBOX{}DeltaChat", delimiter);
+        let mvbox_folder = self
+            .configure_mvbox(context, &["DeltaChat", &fallback_folder], create_mvbox)
+            .await
+            .context("failed to configure mvbox")?;
 
-            match session.create("DeltaChat").await {
-                Ok(_) => {
-                    mvbox_folder = Some("DeltaChat".into());
-                    info!(context, "MVBOX-folder created.",);
-                }
-                Err(err) => {
-                    warn!(
-                        context,
-                        "Cannot create MVBOX-folder, trying to create INBOX subfolder. ({})", err
-                    );
-
-                    match session.create(&fallback_folder).await {
-                        Ok(_) => {
-                            mvbox_folder = Some(fallback_folder);
-                            info!(
-                                context,
-                                "MVBOX-folder created as INBOX subfolder. ({})", err
-                            );
-                        }
-                        Err(err) => {
-                            warn!(context, "Cannot create MVBOX-folder. ({})", err);
-                        }
-                    }
-                }
-            }
-            // SUBSCRIBE is needed to make the folder visible to the LSUB command
-            // that may be used by other MUAs to list folders.
-            // for the LIST command, the folder is always visible.
-            if let Some(ref mvbox) = mvbox_folder {
-                if let Err(err) = session.subscribe(mvbox).await {
-                    warn!(context, "could not subscribe to {:?}: {:?}", mvbox, err);
-                }
-            }
-        }
         context
             .set_config(Config::ConfiguredInboxFolder, Some("INBOX"))
             .await?;
-        if let Some(ref mvbox_folder) = mvbox_folder {
+        if let Some(mvbox_folder) = mvbox_folder {
+            info!(context, "Setting MVBOX FOLDER TO {}", &mvbox_folder);
             context
                 .set_config(Config::ConfiguredMvboxFolder, Some(mvbox_folder))
                 .await?;
@@ -1717,11 +1737,11 @@ async fn should_move_out_of_spam(
         // the SecureJoin header. So, we always move chat messages out of Spam.
         // Two possibilities to change this would be:
         // 1. Remove the `&& !context.is_spam_folder(folder).await?` check from
-        // `fetch_new_messages()`, and then let `dc_receive_imf()` check
+        // `fetch_new_messages()`, and then let `receive_imf()` check
         // if it's a spam message and should be hidden.
         // 2. Or add a flag to the ChatVersion header that this is a securejoin
         // request, and return `true` here only if the message has this flag.
-        // `dc_receive_imf()` can then check if the securejoin request is valid.
+        // `receive_imf()` can then check if the securejoin request is valid.
         return Ok(true);
     }
 
@@ -1922,7 +1942,7 @@ fn get_folder_meaning_by_name(folder_name: &str) -> FolderMeaning {
 
 fn get_folder_meaning(folder_name: &Name) -> FolderMeaning {
     for attr in folder_name.attributes() {
-        if let NameAttribute::Custom(ref label) = attr {
+        if let NameAttribute::Extension(ref label) = attr {
             match label.as_ref() {
                 "\\Trash" => return FolderMeaning::Other,
                 "\\Sent" => return FolderMeaning::Sent,
@@ -2044,10 +2064,6 @@ pub(crate) async fn prefetch_should_download(
     Ok(should_download)
 }
 
-fn get_fallback_folder(delimiter: &str) -> String {
-    format!("INBOX{}DeltaChat", delimiter)
-}
-
 /// Marks messages in `msgs` table as seen, searching for them by UID.
 ///
 /// Returns updated chat ID if any message was marked as seen.
@@ -2388,7 +2404,7 @@ mod tests {
         assert_eq!(get_folder_meaning_by_name("SPAM"), FolderMeaning::Spam);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_set_uid_next_validity() {
         let t = TestContext::new_alice().await;
         assert_eq!(get_uid_next(&t.ctx, "Inbox").await.unwrap(), 0);
@@ -2570,7 +2586,7 @@ mod tests {
         ("Spam", true, true, "DeltaChat"),
     ];
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_target_folder_incoming_accepted() -> Result<()> {
         for (folder, mvbox_move, chat_msg, expected_destination) in COMBINATIONS_ACCEPTED_CHAT {
             check_target_folder_combination(
@@ -2587,7 +2603,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_target_folder_incoming_request() -> Result<()> {
         for (folder, mvbox_move, chat_msg, expected_destination) in COMBINATIONS_REQUEST {
             check_target_folder_combination(
@@ -2604,7 +2620,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_target_folder_outgoing() -> Result<()> {
         // Test outgoing emails
         for (folder, mvbox_move, chat_msg, expected_destination) in COMBINATIONS_ACCEPTED_CHAT {
@@ -2622,7 +2638,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_target_folder_setupmsg() -> Result<()> {
         // Test setupmessages
         for (folder, mvbox_move, chat_msg, _expected_destination) in COMBINATIONS_ACCEPTED_CHAT {
@@ -2640,7 +2656,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_imap_search_command() -> Result<()> {
         let t = TestContext::new_alice().await;
         assert_eq!(

src/imap/client.rs

@@ -8,10 +8,10 @@ use anyhow::{Context as _, Result};
 use async_imap::Client as ImapClient;
 
 use async_smtp::ServerAddress;
-use async_std::net::{self, TcpStream};
+use tokio::net::{self, TcpStream};
 
 use super::session::Session;
-use crate::login_param::{dc_build_tls, Socks5Config};
+use crate::login_param::{build_tls, Socks5Config};
 
 use super::session::SessionStream;
 
@@ -67,7 +67,7 @@ impl Client {
         strict_tls: bool,
     ) -> Result<Self> {
         let stream = TcpStream::connect(addr).await?;
-        let tls = dc_build_tls(strict_tls);
+        let tls = build_tls(strict_tls);
         let tls_stream: Box<dyn SessionStream> = Box::new(tls.connect(domain, stream).await?);
         let mut client = ImapClient::new(tls_stream);
 
@@ -108,7 +108,7 @@ impl Client {
                 .await?,
         );
 
-        let tls = dc_build_tls(strict_tls);
+        let tls = build_tls(strict_tls);
         let tls_stream: Box<dyn SessionStream> =
             Box::new(tls.connect(target_addr.host.clone(), socks5_stream).await?);
         let mut client = ImapClient::new(tls_stream);
@@ -151,7 +151,7 @@ impl Client {
             Ok(self)
         } else {
             let Client { mut inner, .. } = self;
-            let tls = dc_build_tls(strict_tls);
+            let tls = build_tls(strict_tls);
             inner.run_command_and_check_ok("STARTTLS", None).await?;
 
             let stream = inner.into_inner();

src/imap/idle.rs

@@ -2,7 +2,7 @@ use super::Imap;
 
 use anyhow::{bail, Context as _, Result};
 use async_imap::extensions::idle::IdleResponse;
-use async_std::prelude::*;
+use futures_lite::FutureExt;
 use std::time::{Duration, SystemTime};
 
 use crate::{context::Context, scheduler::InterruptInfo};
@@ -87,9 +87,7 @@ impl Imap {
                 }
             }
 
-            let session = handle
-                .done()
-                .timeout(Duration::from_secs(15))
+            let session = tokio::time::timeout(Duration::from_secs(15), handle.done())
                 .await?
                 .context("IMAP IDLE protocol timed out")?;
             self.session = Some(Session { inner: session });
@@ -121,7 +119,7 @@ impl Imap {
 
         // check every minute if there are new messages
         // TODO: grow sleep durations / make them more flexible
-        let mut interval = async_std::stream::interval(Duration::from_secs(60));
+        let mut interval = tokio::time::interval(Duration::from_secs(60));
 
         enum Event {
             Tick,
@@ -131,7 +129,7 @@ impl Imap {
         let info = loop {
             use futures::future::FutureExt;
             match interval
-                .next()
+                .tick()
                 .map(|_| Event::Tick)
                 .race(
                     self.idle_interrupt

src/imap/scan_folders.rs

@@ -1,14 +1,13 @@
 use std::{collections::BTreeMap, time::Instant};
 
 use anyhow::{Context as _, Result};
+use futures::stream::StreamExt;
 
 use crate::config::Config;
 use crate::imap::Imap;
 use crate::log::LogExt;
 use crate::{context::Context, imap::FolderMeaning};
 
-use async_std::stream::StreamExt;
-
 use super::{get_folder_meaning, get_folder_meaning_by_name};
 
 impl Imap {
@@ -104,7 +103,7 @@ impl Imap {
         let list = session
             .list(Some(""), Some("*"))
             .await?
-            .filter_map(|f| f.ok_or_log_msg(context, "list_folders() can't get folder"));
+            .filter_map(|f| async { f.ok_or_log_msg(context, "list_folders() can't get folder") });
         Ok(list.collect().await)
     }
 }

src/imap/session.rs

@@ -2,8 +2,8 @@ use std::ops::{Deref, DerefMut};
 
 use async_imap::Session as ImapSession;
 use async_native_tls::TlsStream;
-use async_std::net::TcpStream;
 use fast_socks5::client::Socks5Stream;
+use tokio::net::TcpStream;
 
 #[derive(Debug)]
 pub(crate) struct Session {
@@ -11,7 +11,7 @@ pub(crate) struct Session {
 }
 
 pub(crate) trait SessionStream:
-    async_std::io::Read + async_std::io::Write + Unpin + Send + Sync + std::fmt::Debug
+    tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + Sync + std::fmt::Debug
 {
 }
 

src/imex.rs

@@ -2,26 +2,21 @@
 
 use std::any::Any;
 use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
 
 use ::pgp::types::KeyTrait;
 use anyhow::{bail, ensure, format_err, Context as _, Result};
-use async_std::{
-    fs::{self, File},
-    path::{Path, PathBuf},
-    prelude::*,
-};
-use async_tar::Archive;
+use futures::{StreamExt, TryStreamExt};
+use futures_lite::FutureExt;
 use rand::{thread_rng, Rng};
+use tokio::fs::{self, File};
+use tokio_tar::Archive;
 
 use crate::blob::BlobObject;
 use crate::chat::{self, delete_and_reset_all_device_msgs, ChatId};
 use crate::config::Config;
 use crate::contact::ContactId;
 use crate::context::Context;
-use crate::dc_tools::{
-    dc_create_folder, dc_delete_file, dc_get_filesuffix_lc, dc_open_file_std, dc_read_file,
-    dc_write_file, time, EmailAddress,
-};
 use crate::e2ee;
 use crate::events::EventType;
 use crate::key::{self, DcKey, DcSecretKey, SignedPublicKey, SignedSecretKey};
@@ -32,6 +27,10 @@ use crate::param::Param;
 use crate::pgp;
 use crate::sql;
 use crate::stock_str;
+use crate::tools::{
+    create_folder, delete_file, get_filesuffix_lc, open_file_std, read_file, time, write_file,
+    EmailAddress,
+};
 
 // Name of the database file in the backup.
 const DBFILE_BACKUP_NAME: &str = "dc_database_backup.sqlite";
@@ -59,7 +58,7 @@ pub enum ImexMode {
     ExportBackup = 11,
 
     /// `path` is the file (not: directory) to import. The file is normally
-    /// created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
+    /// created by DC_IMEX_EXPORT_BACKUP and detected by imex_has_backup(). Importing a backup
     /// is only possible as long as the context is not configured or used in another way.
     ImportBackup = 12,
 }
@@ -109,24 +108,22 @@ pub async fn imex(
 
 /// Returns the filename of the backup found (otherwise an error)
 pub async fn has_backup(_context: &Context, dir_name: &Path) -> Result<String> {
-    let mut dir_iter = async_std::fs::read_dir(dir_name).await?;
+    let mut dir_iter = tokio::fs::read_dir(dir_name).await?;
     let mut newest_backup_name = "".to_string();
     let mut newest_backup_path: Option<PathBuf> = None;
 
-    while let Some(dirent) = dir_iter.next().await {
-        if let Ok(dirent) = dirent {
-            let path = dirent.path();
-            let name = dirent.file_name();
-            let name: String = name.to_string_lossy().into();
-            if name.starts_with("delta-chat")
-                && name.ends_with(".tar")
-                && (newest_backup_name.is_empty() || name > newest_backup_name)
-            {
-                // We just use string comparison to determine which backup is newer.
-                // This works fine because the filenames have the form ...delta-chat-backup-2020-07-24-00.tar
-                newest_backup_path = Some(path);
-                newest_backup_name = name;
-            }
+    while let Ok(Some(dirent)) = dir_iter.next_entry().await {
+        let path = dirent.path();
+        let name = dirent.file_name();
+        let name: String = name.to_string_lossy().into();
+        if name.starts_with("delta-chat")
+            && name.ends_with(".tar")
+            && (newest_backup_name.is_empty() || name > newest_backup_name)
+        {
+            // We just use string comparison to determine which backup is newer.
+            // This works fine because the filenames have the form ...delta-chat-backup-2020-07-24-00.tar
+            newest_backup_path = Some(path);
+            newest_backup_name = name;
         }
     }
 
@@ -177,7 +174,7 @@ async fn do_initiate_key_transfer(context: &Context) -> Result<String> {
     let msg_id = chat::send_msg(context, chat_id, &mut msg).await?;
     info!(context, "Wait for setup message being sent ...",);
     while !context.shall_stop_ongoing().await {
-        async_std::task::sleep(std::time::Duration::from_secs(1)).await;
+        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
         if let Ok(msg) = Message::load_from_db(context, msg_id).await {
             if msg.is_sent() {
                 info!(context, "... setup message sent.",);
@@ -293,7 +290,7 @@ pub async fn continue_key_transfer(
     );
 
     if let Some(filename) = msg.get_file(context) {
-        let file = dc_open_file_std(context, filename)?;
+        let file = open_file_std(context, filename)?;
         let sc = normalize_setup_code(setup_code);
         let armored_key = decrypt_setup_file(&sc, file).await?;
         set_self_key(context, &armored_key, true, true).await?;
@@ -396,7 +393,7 @@ async fn imex_inner(
         if e2ee::ensure_secret_key_exists(context).await.is_err() {
             bail!("Cannot create private key or private key not available.");
         } else {
-            dc_create_folder(context, &path).await?;
+            create_folder(context, &path).await?;
         }
     }
 
@@ -446,7 +443,7 @@ async fn import_backup(
 
     context.sql.config_cache.write().await.clear();
 
-    let archive = Archive::new(backup_file);
+    let mut archive = Archive::new(backup_file);
 
     let mut entries = archive.entries()?;
     let mut last_progress = 0;
@@ -477,7 +474,7 @@ async fn import_backup(
             // async_tar will unpack to blobdir/BLOBS_BACKUP_NAME, so we move the file afterwards.
             f.unpack_in(context.get_blobdir()).await?;
             let from_path = context.get_blobdir().join(f.path()?);
-            if from_path.is_file().await {
+            if from_path.is_file() {
                 if let Some(name) = from_path.file_name() {
                     fs::rename(&from_path, context.get_blobdir().join(name)).await?;
                 } else {
@@ -499,13 +496,10 @@ 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.
-async fn get_next_backup_path(
-    folder: &Path,
-    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(backup_time, 0)
-        // Don't change this file name format, in has_backup() we use string comparison to determine which backup is newer:
+        // Don't change this file name format, in `dc_imex_has_backup` we use string comparison to determine which backup is newer:
         .format("delta-chat-backup-%Y-%m-%d")
         .to_string();
 
@@ -520,7 +514,7 @@ async fn get_next_backup_path(
         let mut destfile = folder.clone();
         destfile.push(format!("{}-{:02}.tar", stem, i));
 
-        if !tempdbfile.exists().await && !tempfile.exists().await && !destfile.exists().await {
+        if !tempdbfile.exists() && !tempfile.exists() && !destfile.exists() {
             return Ok((tempdbfile, tempfile, destfile));
         }
     }
@@ -530,7 +524,7 @@ async 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 (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, now).await?;
+    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());
 
@@ -583,8 +577,9 @@ struct DeleteOnDrop(PathBuf);
 impl Drop for DeleteOnDrop {
     fn drop(&mut self) {
         let file = self.0.clone();
-        // Not using dc_delete_file() here because it would send a DeletedBlobFile event
-        async_std::task::block_on(fs::remove_file(file)).ok();
+        // Not using `tools::delete_file` here because it would send a DeletedBlobFile event
+        // Hack to avoid panic in nested runtime calls of tokio
+        std::fs::remove_file(file).ok();
     }
 }
 
@@ -595,19 +590,21 @@ async fn export_backup_inner(
 ) -> Result<()> {
     let file = File::create(temp_path).await?;
 
-    let mut builder = async_tar::Builder::new(file);
+    let mut builder = tokio_tar::Builder::new(file);
 
     builder
         .append_path_with_name(temp_db_path, DBFILE_BACKUP_NAME)
         .await?;
 
-    let read_dir: Vec<_> = fs::read_dir(context.get_blobdir()).await?.collect().await;
+    let read_dir: Vec<_> =
+        tokio_stream::wrappers::ReadDirStream::new(fs::read_dir(context.get_blobdir()).await?)
+            .try_collect()
+            .await?;
     let count = read_dir.len();
     let mut written_files = 0;
 
     let mut last_progress = 0;
     for entry in read_dir.into_iter() {
-        let entry = entry?;
         let name = entry.file_name();
         if !entry.file_type().await?.is_file() {
             warn!(
@@ -648,12 +645,12 @@ async fn import_self_keys(context: &Context, dir: &Path) -> Result<()> {
     let mut imported_cnt = 0;
 
     let dir_name = dir.to_string_lossy();
-    let mut dir_handle = async_std::fs::read_dir(&dir).await?;
-    while let Some(entry) = dir_handle.next().await {
-        let entry_fn = entry?.file_name();
+    let mut dir_handle = tokio::fs::read_dir(&dir).await?;
+    while let Ok(Some(entry)) = dir_handle.next_entry().await {
+        let entry_fn = entry.file_name();
         let name_f = entry_fn.to_string_lossy();
         let path_plus_name = dir.join(&entry_fn);
-        match dc_get_filesuffix_lc(&name_f) {
+        match get_filesuffix_lc(&name_f) {
             Some(suffix) => {
                 if suffix != "asc" {
                     continue;
@@ -675,7 +672,7 @@ async fn import_self_keys(context: &Context, dir: &Path) -> Result<()> {
             path_plus_name.display()
         );
 
-        match dc_read_file(context, &path_plus_name).await {
+        match read_file(context, &path_plus_name).await {
             Ok(buf) => {
                 let armored = std::string::String::from_utf8_lossy(&buf);
                 if let Err(err) = set_self_key(context, &armored, set_default, false).await {
@@ -778,10 +775,10 @@ where
         key.key_id(),
         file_name.display()
     );
-    dc_delete_file(context, &file_name).await;
+    delete_file(context, &file_name).await;
 
     let content = key.to_asc(None).into_bytes();
-    let res = dc_write_file(context, &file_name, &content).await;
+    let res = write_file(context, &file_name, &content).await;
     if res.is_err() {
         error!(context, "Cannot write key to {}", file_name.display());
     } else {
@@ -800,7 +797,7 @@ mod tests {
 
     use ::pgp::armor::BlockType;
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_render_setup_file() {
         let t = TestContext::new_alice().await;
         let msg = render_setup_file(&t, "hello").await.unwrap();
@@ -817,7 +814,7 @@ mod tests {
         assert!(msg.contains("-----END PGP MESSAGE-----\n"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_render_setup_file_newline_replace() {
         let t = TestContext::new_alice().await;
         t.set_stock_translation(StockMessage::AcSetupMsgBody, "hello\r\nthere".to_string())
@@ -828,7 +825,7 @@ mod tests {
         assert!(msg.contains("<p>hello<br>there</p>"));
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_create_setup_code() {
         let t = TestContext::new().await;
         let setupcode = create_setup_code(&t);
@@ -843,7 +840,7 @@ mod tests {
         assert_eq!(setupcode.chars().nth(39).unwrap(), '-');
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_export_public_key_to_asc_file() {
         let context = TestContext::new().await;
         let key = alice_keypair().public;
@@ -853,12 +850,12 @@ mod tests {
             .is_ok());
         let blobdir = context.ctx.get_blobdir().to_str().unwrap();
         let filename = format!("{}/public-key-default.asc", blobdir);
-        let bytes = async_std::fs::read(&filename).await.unwrap();
+        let bytes = tokio::fs::read(&filename).await.unwrap();
 
         assert_eq!(bytes, key.to_asc(None).into_bytes());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_export_private_key_to_asc_file() {
         let context = TestContext::new().await;
         let key = alice_keypair().secret;
@@ -868,12 +865,12 @@ mod tests {
             .is_ok());
         let blobdir = context.ctx.get_blobdir().to_str().unwrap();
         let filename = format!("{}/private-key-default.asc", blobdir);
-        let bytes = async_std::fs::read(&filename).await.unwrap();
+        let bytes = tokio::fs::read(&filename).await.unwrap();
 
         assert_eq!(bytes, key.to_asc(None).into_bytes());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_export_and_import_key() {
         let context = TestContext::new_alice().await;
         let blobdir = context.ctx.get_blobdir();
@@ -887,7 +884,7 @@ mod tests {
         }
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_export_and_import_backup() -> Result<()> {
         let backup_dir = tempfile::tempdir().unwrap();
 
@@ -896,26 +893,21 @@ mod tests {
 
         let context2 = TestContext::new().await;
         assert!(!context2.is_configured().await?);
-        assert!(has_backup(&context2, backup_dir.path().as_ref())
-            .await
-            .is_err());
+        assert!(has_backup(&context2, backup_dir.path()).await.is_err());
 
         // export from context1
-        assert!(imex(
-            &context1,
-            ImexMode::ExportBackup,
-            backup_dir.path().as_ref(),
-            None,
-        )
-        .await
-        .is_ok());
+        assert!(
+            imex(&context1, ImexMode::ExportBackup, backup_dir.path(), None)
+                .await
+                .is_ok()
+        );
         let _event = context1
             .evtracker
             .get_matching(|evt| matches!(evt, EventType::ImexProgress(1000)))
             .await;
 
         // import to context2
-        let backup = has_backup(&context2, backup_dir.path().as_ref()).await?;
+        let backup = has_backup(&context2, backup_dir.path()).await?;
 
         // Import of unencrypted backup with incorrect "foobar" backup passphrase fails.
         assert!(imex(
@@ -961,7 +953,7 @@ mod tests {
     const S_EM_SETUPCODE: &str = "1742-0185-6197-1303-7016-8412-3581-4441-0597";
     const S_EM_SETUPFILE: &str = include_str!("../test-data/message/stress.txt");
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_split_and_decrypt() {
         let buf_1 = S_EM_SETUPFILE.as_bytes().to_vec();
         let (typ, headers, base64) = split_armored_data(&buf_1).unwrap();
@@ -984,20 +976,20 @@ mod tests {
         assert!(headers.get(HEADER_SETUPCODE).is_none());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_key_transfer() -> Result<()> {
         let alice = TestContext::new_alice().await;
 
         let alice_clone = alice.clone();
-        let key_transfer_task = async_std::task::spawn(async move {
+        let key_transfer_task = tokio::task::spawn(async move {
             let ctx = alice_clone;
             initiate_key_transfer(&ctx).await
         });
 
         // Wait for the message to be added to the queue.
-        async_std::task::sleep(std::time::Duration::from_secs(1)).await;
+        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
         let sent = alice.pop_sent_msg().await;
-        let setup_code = key_transfer_task.await?;
+        let setup_code = key_transfer_task.await??;
 
         // Alice sets up a second device.
         let alice2 = TestContext::new().await;

src/job.rs

@@ -9,10 +9,10 @@ use deltachat_derive::{FromSql, ToSql};
 use rand::{thread_rng, Rng};
 
 use crate::context::Context;
-use crate::dc_tools::time;
 use crate::imap::Imap;
 use crate::param::Params;
 use crate::scheduler::InterruptInfo;
+use crate::tools::time;
 
 // results in ~3 weeks for the last backoff timespan
 const JOB_RETRIES: u32 = 17;
@@ -448,7 +448,7 @@ mod tests {
             .unwrap();
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_load_next_job_two() -> Result<()> {
         // We want to ensure that loading jobs skips over jobs which
         // fails to load from the database instead of failing to load
@@ -464,7 +464,7 @@ mod tests {
         Ok(())
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_load_next_job_one() -> Result<()> {
         let t = TestContext::new().await;
 

src/key.rs

@@ -11,11 +11,12 @@ use num_traits::FromPrimitive;
 use pgp::composed::Deserializable;
 use pgp::ser::Serialize;
 use pgp::types::{KeyTrait, SecretKeyTrait};
+use tokio::runtime::Handle;
 
 use crate::config::Config;
 use crate::constants::KeyGenType;
 use crate::context::Context;
-use crate::dc_tools::{time, EmailAddress};
+use crate::tools::{time, EmailAddress};
 
 // Re-export key types
 pub use crate::pgp::KeyPair;
@@ -39,7 +40,7 @@ pub trait DcKey: Serialize + Deserializable + KeyTrait + Clone {
     /// Create a key from a base64 string.
     fn from_base64(data: &str) -> Result<Self::KeyType> {
         // strip newlines and other whitespace
-        let cleaned: String = data.trim().split_whitespace().collect();
+        let cleaned: String = data.split_whitespace().collect();
         let bytes = base64::decode(cleaned.as_bytes())?;
         Self::from_slice(&bytes)
     }
@@ -219,9 +220,10 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
             let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType).await?)
                 .unwrap_or_default();
             info!(context, "Generating keypair with type {}", keytype);
-            let keypair =
-                async_std::task::spawn_blocking(move || crate::pgp::create_keypair(addr, keytype))
-                    .await?;
+            let keypair = Handle::current()
+                .spawn_blocking(move || crate::pgp::create_keypair(addr, keytype))
+                .await??;
+
             store_self_keypair(context, &keypair, KeyPairUse::Default).await?;
             info!(
                 context,
@@ -397,8 +399,8 @@ mod tests {
     use super::*;
     use crate::test_utils::{alice_keypair, TestContext};
 
-    use async_std::sync::Arc;
     use once_cell::sync::Lazy;
+    use std::sync::Arc;
 
     static KEYPAIR: Lazy<KeyPair> = Lazy::new(alice_keypair);
 
@@ -520,7 +522,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
         assert_eq!(key, key2);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_load_self_existing() {
         let alice = alice_keypair();
         let t = TestContext::new_alice().await;
@@ -530,7 +532,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
         assert_eq!(alice.secret, seckey);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_load_self_generate_public() {
         let t = TestContext::new().await;
         t.set_config(Config::ConfiguredAddr, Some("alice@example.org"))
@@ -540,7 +542,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
         assert!(key.is_ok());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_load_self_generate_secret() {
         let t = TestContext::new().await;
         t.set_config(Config::ConfiguredAddr, Some("alice@example.org"))
@@ -550,7 +552,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
         assert!(key.is_ok());
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_load_self_generate_concurrent() {
         use std::thread;
 
@@ -560,11 +562,19 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
             .unwrap();
         let thr0 = {
             let ctx = t.clone();
-            thread::spawn(move || async_std::task::block_on(SignedPublicKey::load_self(&ctx)))
+            thread::spawn(move || {
+                tokio::runtime::Runtime::new()
+                    .unwrap()
+                    .block_on(SignedPublicKey::load_self(&ctx))
+            })
         };
         let thr1 = {
             let ctx = t.clone();
-            thread::spawn(move || async_std::task::block_on(SignedPublicKey::load_self(&ctx)))
+            thread::spawn(move || {
+                tokio::runtime::Runtime::new()
+                    .unwrap()
+                    .block_on(SignedPublicKey::load_self(&ctx))
+            })
         };
         let res0 = thr0.join().unwrap();
         let res1 = thr1.join().unwrap();
@@ -577,7 +587,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
         assert_eq!(pubkey.primary_key, KEYPAIR.public.primary_key);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_save_self_key_twice() {
         // Saving the same key twice should result in only one row in
         // the keypairs table.

src/keyring.rs

@@ -76,7 +76,7 @@ mod tests {
         assert_eq!(sec_ring.keys(), [alice.secret]);
     }
 
-    #[async_std::test]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_keyring_load_self() {
         // new_self() implies load_self()
         let t = TestContext::new_alice().await;