sipmlify, no randomness anymore

.github/workflows/code-quality.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: nightly-2020-03-19
+          toolchain: nightly-2020-03-12
           override: true
       - uses: actions-rs/cargo@v1
         with:
@@ -25,7 +25,7 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: nightly-2020-03-19
+          toolchain: nightly-2020-03-12
           override: true
       - run: rustup component add rustfmt
       - uses: actions-rs/cargo@v1
@@ -39,7 +39,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions-rs/toolchain@v1
         with:
-            toolchain: nightly-2020-03-19
+            toolchain: nightly-2020-03-12
             components: clippy
             override: true
       - uses: actions-rs/clippy-check@v1

ASYNC-API-TODO.txt

@@ -1,54 +0,0 @@
-
-Delta Chat ASYNC  (friedel, bjoern, floris, friedel)
-
-- smtp fake-idle/load jobs gerade noch alle fuenf sekunden , sollte alle zehn minuten (oder gar nicht)
-
-APIs:
-    dc_context_new                 # opens the database
-    dc_open                             # FFI only
-      -> drop it and move parameters to dc_context_new()
-
-    dc_configure                      # note: dc_start_jobs() is NOT allowed to run concurrently
-    dc_imex NEVER goes through the job system
-    dc_imex import_backup needs to ensure dc_stop_jobs()
-
-    dc_start_io                # start smtp/imap and job handling subsystems
-    dc_stop_io                 # stop smtp/imap and job handling subsystems
-    dc_is_io_running           # return 1 if smtp/imap/jobs susbystem is running
-
-    dc_close                            # FFI only
-      -> can be dropped
-    dc_context_unref
-
-    for ios share-extension:
-    Int dc_direct_send()  -> try send out without going through jobs system, but queue a job in db if it needs to be retried on failure
-        0: message was sent
-        1: message failed to go out, is queued as a job to be retried later
-        2: message permanently failed?
-
-EVENT handling:
-    start a callback thread and call get_next_event() which is BLOCKING
-    it's fine to start this callback thread later, it will see all events.
-    Note that the core infinitely fills the internal queue if you never drain it.
-
-    FFI-get_next_event() returns NULL if the context is unrefed already?
-
-   sidenote: how python's callback thread does it currently:
-         CB-thread runs this while loop:
-         while not QUITFLAG:
-             ev = context.get_next_event( )
-             ...
-         So in order to shutdown properly one has to set QUITFLAG
-         before calling dc_stop_jobs() and dc_context_unref
-
-    event API:
-        get_data1_int
-        get_data2_int
-        get_data3_str
-
-
-- userdata likely only used for the callbacks, likely can be dropped, needs verification
-
-
-- iOS needs for the share app to call "try_send_smtp" wihtout a full dc_context_run and without going
-

CHANGELOG.md

@@ -1,21 +1,5 @@
 # Changelog 
 
-## 1.34.0
-
-- new api for io, thread and event handling #1356,
-  see the example atop of `deltachat.h` to get an overview
-
-- LOTS of speed improvements due to async processing #1356
-
-- enable WAL mode for sqlite #1492
-
-- process incoming messages in bulk #1527
-
-- improve finding out the sent-folder #1488
-
-- several bug fixes
-
-
 ## 1.33.0
 
 - let `dc_set_muted()` also mute one-to-one chats #1470

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "deltachat"
-version = "1.34.0"
+version = "1.33.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL-2.0"
 
 [profile.release]
-# lto = true
+lto = true
 
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
@@ -17,15 +17,15 @@ hex = "0.4.0"
 sha2 = "0.8.0"
 rand = "0.7.0"
 smallvec = "1.0.0"
-surf = { version = "2.0.0-alpha.2", default-features = false, features = ["h1-client"] }
+reqwest = { version = "0.10.0", features = ["blocking", "json"] }
 num-derive = "0.3.0"
 num-traits = "0.2.6"
-async-smtp = { version = "0.3" }
+async-smtp = "0.2"
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
-async-imap = "0.3.1"
-async-native-tls = { version = "0.3.3" }
-async-std = { version = "1.6.0", features = ["unstable"] }
+async-imap = "0.2"
+async-native-tls = "0.3.1"
+async-std = { version = "1.4", features = ["unstable"] }
 base64 = "0.11"
 charset = "0.1"
 percent-encoding = "2.0"
@@ -35,11 +35,12 @@ chrono = "0.4.6"
 indexmap = "1.3.0"
 lazy_static = "1.4.0"
 regex = "1.1.6"
-rusqlite = { version = "0.22", features = ["bundled"] }
-r2d2_sqlite = "0.15.0"
+rusqlite = { version = "0.21", features = ["bundled"] }
+r2d2_sqlite = "0.13.0"
 r2d2 = "0.8.5"
 strum = "0.16.0"
 strum_macros = "0.16.0"
+thread-local-object = "0.1.0"
 backtrace = "0.3.33"
 byteorder = "1.3.1"
 itertools = "0.8.0"
@@ -50,29 +51,21 @@ bitflags = "1.1.0"
 debug_stub_derive = "0.3.0"
 sanitize-filename = "0.2.1"
 stop-token = { version = "0.1.1", features = ["unstable"] }
-mailparse = "0.12.1"
+mailparse = "0.12.0"
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch="master" }
 native-tls = "0.2.3"
 image = { version = "0.22.4", default-features=false, features = ["gif_codec", "jpeg", "ico", "png_codec", "pnm", "webp", "bmp"] }
-futures = "0.3.4"
+pretty_env_logger = "0.3.1"
+
+rustyline = { version = "4.1.0", optional = true }
 thiserror = "1.0.14"
 anyhow = "1.0.28"
-async-trait = "0.1.31"
-url = "2.1.1"
-
-pretty_env_logger = { version = "0.3.1", optional = true }
-log = {version = "0.4.8", optional = true }
-rustyline = { version = "4.1.0", optional = true }
-ansi_term = { version = "0.12.1", optional = true }
-
 
 [dev-dependencies]
 tempfile = "3.0"
 pretty_assertions = "0.6.1"
 pretty_env_logger = "0.3.0"
 proptest = "0.9.4"
-async-std = { version = "1.6.0", features = ["unstable", "attributes"] }
-smol = "0.1.10"
 
 [workspace]
 members = [
@@ -83,20 +76,15 @@ members = [
 [[example]]
 name = "simple"
 path = "examples/simple.rs"
-required-features = ["repl"]
 
 [[example]]
 name = "repl"
 path = "examples/repl/main.rs"
-required-features = ["repl"]
+required-features = ["rustyline"]
 
 
 [features]
-default = []
-internals = []
-repl = ["internals", "rustyline", "log", "pretty_env_logger", "ansi_term"]
-vendored = ["async-native-tls/vendored", "async-smtp/native-tls-vendored"]
+default = ["nightly"]
+vendored = ["async-native-tls/vendored", "reqwest/native-tls-vendored", "async-smtp/native-tls-vendored"]
 nightly = ["pgp/nightly"]
 
-[patch.crates-io]
-smol = { git = "https://github.com/dignifiedquire/smol-1", branch = "isolate-nix" }

README.md

@@ -9,7 +9,7 @@
 To download and install the official compiler for the Rust programming language, and the Cargo package manager, run the command in your user environment:
 
 ```
-$ curl https://sh.rustup.rs -sSf | sh
+curl https://sh.rustup.rs -sSf | sh
 ```
 
 ## Using the CLI client
@@ -17,7 +17,7 @@ $ curl https://sh.rustup.rs -sSf | sh
 Compile and run Delta Chat Core command line utility, using `cargo`:
 
 ```
-$ RUST_LOG=info cargo run --example repl --features repl -- ~/deltachat-db
+cargo run --example repl -- ~/deltachat-db
 ```
 where ~/deltachat-db is the database file. Delta Chat will create it if it does not exist.
 
@@ -132,5 +132,4 @@ or its language bindings:
 - [iOS](https://github.com/deltachat/deltachat-ios)
 - [Desktop](https://github.com/deltachat/deltachat-desktop)
 - [Pidgin](https://code.ur.gs/lupine/purple-plugin-delta/)
-- [Telepathy](https://code.ur.gs/lupine/telepathy-padfoot/)
 - several **Bots**

appveyor.yml

@@ -4,7 +4,7 @@ environment:
 
 install:
   - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - rustup-init -yv --default-toolchain nightly-2020-03-19
+  - rustup-init -yv --default-toolchain nightly-2020-03-12
   - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
   - rustc -vV
   - cargo -vV

ci_scripts/docker-coredeps/Dockerfile

@@ -1,4 +1,4 @@
-FROM quay.io/pypa/manylinux2010_x86_64
+FROM quay.io/pypa/manylinux1_x86_64
 
 # Configure ld.so/ldconfig and pkg-config
 RUN echo /usr/local/lib64 > /etc/ld.so.conf.d/local.conf && \

ci_scripts/docker-coredeps/deps/build_rust.sh

@@ -3,9 +3,9 @@
 set -e -x
 
 # Install Rust
-curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain 1.43.1-x86_64-unknown-linux-gnu -y
+curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2020-03-12 -y
 export PATH=/root/.cargo/bin:$PATH
 rustc --version
 
 # remove some 300-400 MB that we don't need for automated builds
-rm -rf /root/.rustup/toolchains/1.43.1-x86_64-unknown-linux-gnu/share
+rm -rf /root/.rustup/toolchains/nightly-2020-03-12-x86_64-unknown-linux-gnu/share/

ci_scripts/remote_python_packaging.sh

@@ -46,6 +46,6 @@ echo "--- Running $CIRCLE_JOB remotely"
 
 ssh -t $SSHTARGET bash "$BUILDDIR/exec_docker_run"
 mkdir -p workspace 
-rsync -avz "$SSHTARGET:$BUILDDIR/python/.docker-tox/wheelhouse/*manylinux201*" workspace/wheelhouse/
+rsync -avz "$SSHTARGET:$BUILDDIR/python/.docker-tox/wheelhouse/*manylinux1*" workspace/wheelhouse/
 rsync -avz "$SSHTARGET:$BUILDDIR/python/.docker-tox/dist/*" workspace/wheelhouse/
 rsync -avz "$SSHTARGET:$BUILDDIR/python/doc/_build/" workspace/py-docs

ci_scripts/run_all.sh

@@ -21,8 +21,7 @@ export DCC_RS_DEV=$(pwd)
 export PATH=$PATH:/opt/python/cp35-cp35m/bin
 export PYTHONDONTWRITEBYTECODE=1
 pushd /bin
-rm -f python3.5
-ln -s /opt/python/cp35-cp35m/bin/python3.5
+ln -s /opt/python/cp27-cp27m/bin/python2.7
 ln -s /opt/python/cp36-cp36m/bin/python3.6
 ln -s /opt/python/cp37-cp37m/bin/python3.7
 ln -s /opt/python/cp38-cp38/bin/python3.8

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.34.0"
+version = "1.33.0"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
@@ -20,12 +20,10 @@ libc = "0.2"
 human-panic = "1.0.1"
 num-traits = "0.2.6"
 serde_json = "1.0"
-async-std = "1.6.0"
 anyhow = "1.0.28"
 thiserror = "1.0.14"
 
 [features]
-default = ["vendored"]
+default = ["vendored", "nightly"]
 vendored = ["deltachat/vendored"]
 nightly = ["deltachat/nightly"]
-

deltachat-ffi/deltachat.h

@@ -19,8 +19,6 @@ typedef struct _dc_msg      dc_msg_t;
 typedef struct _dc_contact  dc_contact_t;
 typedef struct _dc_lot      dc_lot_t;
 typedef struct _dc_provider dc_provider_t;
-typedef struct _dc_event    dc_event_t;
-typedef struct _dc_event_emitter dc_event_emitter_t;
 
 
 /**
@@ -32,40 +30,63 @@ typedef struct _dc_event_emitter dc_event_emitter_t;
  *
  * Let's start.
  *
- * First of all, you have to **create a context object**
- * bound to a database.
- * The database is a normal sqlite-file and is created as needed:
+ * First of all, you have to **define an event-handler-function**
+ * that is called by the library on specific events
+ * (eg. when the configuration is done or when fresh messages arrive).
+ * With this function you can create a Delta Chat context then:
  *
  * ~~~
- * dc_context_t* context = dc_context_new(NULL, "example.db", NULL);
- * ~~~
+ * #include <deltachat.h>
  *
- * After that, make sure, you can **receive events from the context**.
- * For that purpose, create an event emitter you can ask for events.
- * If there are no event, the emitter will wait until there is one,
- * so, in many situations you will do this in a thread:
- *
- * ~~~
- * void* event_handler(void* context)
+ * uintptr_t event_handler_func(dc_context_t* context, int event,
+ *                              uintptr_t data1, uintptr_t data2)
  * {
- *     dc_event_emitter_t* emitter = dc_get_event_emitter(context);
- *     dc_event_t* event;
- *     while ((event = dc_get_next_event(emitter)) != NULL) {
- *         // use the event as needed, eg. dc_event_get_id() returns the type.
- *         // once you're done, unref the event to avoid memory leakage:
- *         dc_event_unref(event);
- *     }
- *     dc_event_emitter_unref(emitter);
+ *     return 0;
  * }
  *
- * static pthread_t event_thread;
- * pthread_create(&event_thread, NULL, event_handler, context);
+ * dc_context_t* context = dc_context_new(event_handler_func, NULL, NULL);
+ * ~~~
+ *
+ * After that, you should make sure,
+ * sending and receiving jobs are processed as needed.
+ * For this purpose, you have to **create two threads:**
+ *
+ * ~~~
+ * #include <pthread.h>
+ *
+ * void* imap_thread_func(void* context)
+ * {
+ *     while (true) {
+ *         dc_perform_imap_jobs(context);
+ *         dc_perform_imap_fetch(context);
+ *         dc_perform_imap_idle(context);
+ *     }
+ * }
+ *
+ * void* smtp_thread_func(void* context)
+ * {
+ *     while (true) {
+ *         dc_perform_smtp_jobs(context);
+ *         dc_perform_smtp_idle(context);
+ *     }
+ * }
+ *
+ * static pthread_t imap_thread, smtp_thread;
+ * pthread_create(&imap_thread, NULL, imap_thread_func, context);
+ * pthread_create(&smtp_thread, NULL, smtp_thread_func, context);
  * ~~~
  *
  * The example above uses "pthreads",
  * however, you can also use anything else for thread handling.
  * All deltachat-core-functions, unless stated otherwise, are thread-safe.
  *
+ * After that you can  **define and open a database.**
+ * The database is a normal sqlite-file and is created as needed:
+ *
+ * ~~~
+ * dc_open(context, "example.db", NULL);
+ * ~~~
+ *
  * Now you can **configure the context:**
  *
  * ~~~
@@ -75,22 +96,15 @@ typedef struct _dc_event_emitter dc_event_emitter_t;
  * dc_configure(context);
  * ~~~
  *
- * dc_configure() returns immediately,
- * the configuration itself runs in background and may take a while.
+ * dc_configure() returns immediately, the configuration itself may take a while
+ * and is done by a job in the imap-thread you've defined above.
  * Once done, the #DC_EVENT_CONFIGURE_PROGRESS reports success
- * to the event_handler() you've defined above.
+ * to the event_handler_func() that is also defined above.
  *
  * The configuration result is saved in the database,
  * on subsequent starts it is not needed to call dc_configure()
  * (you can check this using dc_is_configured()).
  *
- * On a successfully configured context,
- * you can finally **connect to the servers:**
- *
- * ~~~
- * dc_start_io(context);
- * ~~~
- *
  * Now you can **send the first message:**
  *
  * ~~~
@@ -102,11 +116,11 @@ typedef struct _dc_event_emitter dc_event_emitter_t;
  * ~~~
  *
  * dc_send_text_msg() returns immediately;
- * the sending itself is done in the background.
+ * the sending itself is done by a job in the smtp-thread you've defined above.
  * If you check the testing address (bob)
  * and you should have received a normal email.
  * Answer this email in any email program with "Got it!"
- * and the IO you started above will **receive the message**.
+ * and the imap-thread you've create above will **receive the message**.
  *
  * You can then **list all messages** of a chat as follow:
  *
@@ -148,7 +162,20 @@ typedef struct _dc_event_emitter dc_event_emitter_t;
  * - Strings in function arguments or return values are usually UTF-8 encoded.
  *
  * - The issue-tracker for the core library is here:
- *   <https://github.com/deltachat/deltachat-core-rust/issues>
+ *   <https://github.com/deltachat/deltachat-core/issues>
+ *
+ * The following points are important mainly
+ * for the authors of the library itself:
+ *
+ * - For indentation, use tabs.
+ *   Alignments that are not placed at the beginning of a line
+ *   should be done with spaces.
+ *
+ * - For padding between functions,
+ *   classes etc. use 2 empty lines
+ *
+ * - Source files are encoded as UTF-8 with Unix line endings
+ *   (a simple `LF`, `0x0A` or `\n`)
  *
  * If you need further assistance,
  * please do not hesitate to contact us
@@ -172,6 +199,20 @@ typedef struct _dc_event_emitter dc_event_emitter_t;
  * settings.
  */
 
+
+/**
+ * Callback function that should be given to dc_context_new().
+ *
+ * @memberof dc_context_t
+ * @param context The context object as returned by dc_context_new().
+ * @param event one of the @ref DC_EVENT constants
+ * @param data1 depends on the event parameter
+ * @param data2 depends on the event parameter
+ * @return events do not expect a return value, just always return 0
+ */
+typedef uintptr_t (*dc_callback_t) (dc_context_t* context, int event, uintptr_t data1, uintptr_t data2);
+
+
 // create/open/config/information
 
 /**
@@ -179,6 +220,18 @@ typedef struct _dc_event_emitter dc_event_emitter_t;
  * opened, connected and mails are fetched.
  *
  * @memberof dc_context_t
+ * @param cb a callback function that is called for events (update,
+ *     state changes etc.) and to get some information from the client (eg. translation
+ *     for a given string).
+ *     See @ref DC_EVENT for a list of possible events that may be passed to the callback.
+ *     - The callback MAY be called from _any_ thread, not only the main/GUI thread!
+ *     - The callback MUST NOT call any dc_* and related functions unless stated
+ *       otherwise!
+ *     - The callback SHOULD return _fast_, for GUI updates etc. you should
+ *       post yourself an asynchronous message to your GUI thread, if needed.
+ *     - events do not expect a return value, just always return 0.
+ * @param userdata can be used by the client for any purpuse.  He finds it
+ *     later in dc_get_userdata().
  * @param os_name is only for decorative use
  *     and is shown eg. in the `X-Mailer:` header
  *     in the form "Delta Chat Core <version>/<os_name>".
@@ -186,16 +239,11 @@ typedef struct _dc_event_emitter dc_event_emitter_t;
  *     the used environment and/or the version here.
  *     It is okay to give NULL, in this case `X-Mailer:` header
  *     is set to "Delta Chat Core <version>".
- * @param dbfile The file to use to store the database,
- *     something like `~/file` won't work, use absolute paths.
- * @param blobdir A directory to store the blobs in; a trailing slash is not needed.
- *     If you pass NULL or the empty string, deltachat-core creates a directory
- *     beside _dbfile_ with the same name and the suffix `-blobs`.
  * @return A context object with some public members.
  *     The object must be passed to the other context functions
  *     and must be freed using dc_context_unref() after usage.
  */
-dc_context_t*   dc_context_new               (const char* os_name, const char* dbfile, const char* blobdir);
+dc_context_t*   dc_context_new               (dc_callback_t cb, void* userdata, const char* os_name);
 
 
 /**
@@ -214,21 +262,56 @@ void            dc_context_unref             (dc_context_t* context);
 
 
 /**
- * Create the event emitter that is used to receive events.
- * The library will emit various @ref DC_EVENT events as "new message", "message read" etc.
- * To get these events, you have to create an event emitter using this function
- * and call dc_get_next_event() on the emitter.
+ * Get user data associated with a context object.
  *
  * @memberof dc_context_t
  * @param context The context object as created by dc_context_new().
- * @return Returns the event emitter, NULL on errors.
- *     Must be freed using dc_event_emitter_unref() after usage.
- *
- * Note: Use only one event emitter per context.
- * Having more than one event emitter running at the same time on the same context
- * will result in events randomly delivered to the one or to the other.
+ * @return User data, this is the second parameter given to dc_context_new().
  */
-dc_event_emitter_t* dc_get_event_emitter(dc_context_t* context);
+void*           dc_get_userdata              (dc_context_t* context);
+
+
+/**
+ * Open context database.  If the given file does not exist, it is
+ * created and can be set up using dc_set_config() afterwards.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as created by dc_context_new().
+ * @param dbfile The file to use to store the database, something like `~/file` won't
+ *     work on all systems, if in doubt, use absolute paths.
+ * @param blobdir A directory to store the blobs in; a trailing slash is not needed.
+ *     If you pass NULL or the empty string, deltachat-core creates a directory
+ *     beside _dbfile_ with the same name and the suffix `-blobs`.
+ * @return 1 on success, 0 on failure
+ *     eg. if the file is not writable
+ *     or if there is already a database opened for the context.
+ */
+int             dc_open                      (dc_context_t* context, const char* dbfile, const char* blobdir);
+
+
+/**
+ * Close context database opened by dc_open().
+ * Before this, connections to SMTP and IMAP are closed; these connections
+ * are started automatically as needed eg. by sending for fetching messages.
+ * This function is also implicitly called by dc_context_unref().
+ * Multiple calls to this functions are okay, the function takes care not
+ * to free objects twice.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as created by dc_context_new().
+ * @return None.
+ */
+void            dc_close                     (dc_context_t* context);
+
+
+/**
+ * Check if the context database is open.
+ *
+ * @memberof dc_context_t
+ * @param context The context object as created by dc_context_new().
+ * @return 0=context is not open, 1=context is open.
+ */
+int             dc_is_open                   (const dc_context_t* context);
 
 
 /**
@@ -430,7 +513,9 @@ char*           dc_get_oauth2_url            (dc_context_t* context, const char*
 
 /**
  * Configure a context.
- * While configuration IO must not be started, if needed stop IO using dc_stop_io() first.
+ * For this purpose, the function creates a job
+ * that is executed in the IMAP-thread then;
+ * this requires to call dc_perform_imap_jobs() regularly.
  * If the context is already configured,
  * this function will try to change the configuration.
  *
@@ -492,40 +577,311 @@ void            dc_configure                 (dc_context_t* context);
  * @return 1=context is configured and can be used;
  *     0=context is not configured and a configuration by dc_configure() is required.
  */
-int             dc_is_configured   (const dc_context_t* context);
+int             dc_is_configured             (const dc_context_t* context);
 
 
 /**
- * Start job and IMAP/SMTP tasks.
- * If IO is already running, nothing happens.
- * To check the current IO state, use dc_is_io_running().
+ * Execute pending imap-jobs.
+ * This function and dc_perform_imap_fetch() and dc_perform_imap_idle()
+ * must be called from the same thread, typically in a loop.
+ *
+ * Example:
+ *
+ *     void* imap_thread_func(void* context)
+ *     {
+ *         while (true) {
+ *             dc_perform_imap_jobs(context);
+ *             dc_perform_imap_fetch(context);
+ *             dc_perform_imap_idle(context);
+ *         }
+ *     }
+ *
+ *     // start imap-thread that runs forever
+ *     pthread_t imap_thread;
+ *     pthread_create(&imap_thread, NULL, imap_thread_func, context);
+ *
+ *     ... program runs ...
+ *
+ *     // network becomes available again -
+ *     // the interrupt causes dc_perform_imap_idle() in the thread above
+ *     // to return so that jobs are executed and messages are fetched.
+ *     dc_maybe_network(context);
  *
  * @memberof dc_context_t
- * @param context The context object as created by dc_context_new().
- * @return None
+ * @param context The context as created by dc_context_new().
+ * @return None.
  */
-void            dc_start_io     (dc_context_t* context);
+void            dc_perform_imap_jobs         (dc_context_t* context);
+
 
 /**
- * Check if IO (SMTP/IMAP/Jobs) has been started.
+ * Fetch new messages, if any.
+ * This function and dc_perform_imap_jobs() and dc_perform_imap_idle() must be called from the same thread,
+ * typically in a loop.
+ *
+ * See dc_perform_imap_jobs() for an example.
  *
  * @memberof dc_context_t
- * @param context The context object as created by dc_context_new().
- * @return 1=IO is running; 
- *   0=IO is not running.
+ * @param context The context as created by dc_context_new().
+ * @return None.
  */
-int             dc_is_io_running(const dc_context_t* context);
+void            dc_perform_imap_fetch        (dc_context_t* context);
+
 
 /**
- * Stop job and IMAP/SMTP tasks and return when they are finished. 
- * If IO is not running, nothing happens.
- * To check the current IO state, use dc_is_io_running().
+ * Wait for messages or jobs.
+ * This function and dc_perform_imap_jobs() and dc_perform_imap_fetch() must be called from the same thread,
+ * typically in a loop.
+ *
+ * You should call this function directly after calling dc_perform_imap_fetch().
+ *
+ * See dc_perform_imap_jobs() for an example.
  *
  * @memberof dc_context_t
- * @param context The context object as created by dc_context_new().
- * @return None
+ * @param context The context as created by dc_context_new().
+ * @return None.
  */
-void            dc_stop_io(dc_context_t* context);
+void            dc_perform_imap_idle         (dc_context_t* context);
+
+
+/**
+ * Interrupt waiting for imap-jobs.
+ * If dc_perform_imap_jobs(), dc_perform_imap_fetch() and dc_perform_imap_idle() are called in a loop,
+ * calling this function causes imap-jobs to be executed and messages to be fetched.
+ *
+ * dc_interrupt_imap_idle() does _not_ interrupt dc_perform_imap_jobs() or dc_perform_imap_fetch().
+ * If the imap-thread is inside one of these functions when dc_interrupt_imap_idle() is called, however,
+ * the next call of the imap-thread to dc_perform_imap_idle() is interrupted immediately.
+ *
+ * Internally, this function is called whenever a imap-jobs should be processed
+ * (delete message, markseen etc.).
+ *
+ * When you need to call this function just because to get jobs done after network changes,
+ * use dc_maybe_network() instead.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_interrupt_imap_idle       (dc_context_t* context);
+
+
+/**
+ * Execute pending mvbox-jobs.
+ * This function and dc_perform_mvbox_fetch() and dc_perform_mvbox_idle()
+ * must be called from the same thread, typically in a loop.
+ *
+ * Example:
+ *
+ *     void* mvbox_thread_func(void* context)
+ *     {
+ *         while (true) {
+ *             dc_perform_mvbox_jobs(context);
+ *             dc_perform_mvbox_fetch(context);
+ *             dc_perform_mvbox_idle(context);
+ *         }
+ *     }
+ *
+ *     // start mvbox-thread that runs forever
+ *     pthread_t mvbox_thread;
+ *     pthread_create(&mvbox_thread, NULL, mvbox_thread_func, context);
+ *
+ *     ... program runs ...
+ *
+ *     // network becomes available again -
+ *     // the interrupt causes dc_perform_mvbox_idle() in the thread above
+ *     // to return so that jobs are executed and messages are fetched.
+ *     dc_maybe_network(context);
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_mvbox_jobs         (dc_context_t* context);
+
+
+/**
+ * Fetch new messages from the MVBOX, if any.
+ * The MVBOX is a folder on the account where chat messages are moved to.
+ * The moving is done to not disturb shared accounts that are used by both,
+ * Delta Chat and a classical MUA.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_mvbox_fetch       (dc_context_t* context);
+
+
+/**
+ * Wait for messages or jobs in the MVBOX-thread.
+ * This function and dc_perform_mvbox_fetch().
+ * must be called from the same thread, typically in a loop.
+ *
+ * You should call this function directly after calling dc_perform_mvbox_fetch().
+ *
+ * See dc_perform_mvbox_fetch() for an example.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_mvbox_idle        (dc_context_t* context);
+
+
+/**
+ * Interrupt waiting for MVBOX-fetch.
+ * dc_interrupt_mvbox_idle() does _not_ interrupt dc_perform_mvbox_fetch().
+ * If the MVBOX-thread is inside this function when dc_interrupt_mvbox_idle() is called, however,
+ * the next call of the MVBOX-thread to dc_perform_mvbox_idle() is interrupted immediately.
+ *
+ * Internally, this function is called whenever a imap-jobs should be processed.
+ *
+ * When you need to call this function just because to get jobs done after network changes,
+ * use dc_maybe_network() instead.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_interrupt_mvbox_idle      (dc_context_t* context);
+
+
+/**
+ * Execute pending sentbox-jobs.
+ * This function and dc_perform_sentbox_fetch() and dc_perform_sentbox_idle()
+ * must be called from the same thread, typically in a loop.
+ *
+ * Example:
+ *
+ *     void* sentbox_thread_func(void* context)
+ *     {
+ *         while (true) {
+ *             dc_perform_sentbox_jobs(context);
+ *             dc_perform_sentbox_fetch(context);
+ *             dc_perform_sentbox_idle(context);
+ *         }
+ *     }
+ *
+ *     // start sentbox-thread that runs forever
+ *     pthread_t sentbox_thread;
+ *     pthread_create(&sentbox_thread, NULL, sentbox_thread_func, context);
+ *
+ *     ... program runs ...
+ *
+ *     // network becomes available again -
+ *     // the interrupt causes dc_perform_sentbox_idle() in the thread above
+ *     // to return so that jobs are executed and messages are fetched.
+ *     dc_maybe_network(context);
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_sentbox_jobs         (dc_context_t* context);
+
+
+/**
+ * Fetch new messages from the Sent folder, if any.
+ * This function and dc_perform_sentbox_idle()
+ * must be called from the same thread, typically in a loop.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_sentbox_fetch     (dc_context_t* context);
+
+
+/**
+ * Wait for messages or jobs in the SENTBOX-thread.
+ * This function and dc_perform_sentbox_fetch()
+ * must be called from the same thread, typically in a loop.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_sentbox_idle      (dc_context_t* context);
+
+
+/**
+ * Interrupt waiting for messages or jobs in the SENTBOX-thread.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_interrupt_sentbox_idle    (dc_context_t* context);
+
+
+/**
+ * Execute pending smtp-jobs.
+ * This function and dc_perform_smtp_idle() must be called from the same thread,
+ * typically in a loop.
+ *
+ * Example:
+ *
+ *     void* smtp_thread_func(void* context)
+ *     {
+ *         while (true) {
+ *             dc_perform_smtp_jobs(context);
+ *             dc_perform_smtp_idle(context);
+ *         }
+ *     }
+ *
+ *     // start smtp-thread that runs forever
+ *     pthread_t smtp_thread;
+ *     pthread_create(&smtp_thread, NULL, smtp_thread_func, context);
+ *
+ *     ... program runs ...
+ *
+ *     // network becomes available again -
+ *     // the interrupt causes dc_perform_smtp_idle() in the thread above
+ *     // to return so that jobs are executed
+ *     dc_maybe_network(context);
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_smtp_jobs         (dc_context_t* context);
+
+
+/**
+ * Wait for smtp-jobs.
+ * This function and dc_perform_smtp_jobs() must be called from the same thread,
+ * typically in a loop.
+ *
+ * See dc_interrupt_smtp_idle() for an example.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_perform_smtp_idle         (dc_context_t* context);
+
+
+/**
+ * Interrupt waiting for smtp-jobs.
+ * If dc_perform_smtp_jobs() and dc_perform_smtp_idle() are called in a loop,
+ * calling this function causes jobs to be executed.
+ *
+ * dc_interrupt_smtp_idle() does _not_ interrupt dc_perform_smtp_jobs().
+ * If the smtp-thread is inside this function when dc_interrupt_smtp_idle() is called, however,
+ * the next call of the smtp-thread to dc_perform_smtp_idle() is interrupted immediately.
+ *
+ * Internally, this function is called whenever a message is to be sent.
+ *
+ * When you need to call this function just because to get jobs done after network changes,
+ * use dc_maybe_network() instead.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_interrupt_smtp_idle       (dc_context_t* context);
+
 
 /**
  * This function can be called whenever there is a hint
@@ -539,7 +895,6 @@ void            dc_stop_io(dc_context_t* context);
 void            dc_maybe_network             (dc_context_t* context);
 
 
-
 /**
  * Save a keypair as the default keys for the user.
  *
@@ -766,23 +1121,6 @@ uint32_t        dc_prepare_msg               (dc_context_t* context, uint32_t ch
  */
 uint32_t        dc_send_msg                  (dc_context_t* context, uint32_t chat_id, dc_msg_t* msg);
 
-/**
- * Send a message defined by a dc_msg_t object to a chat, synchronously.
- * This bypasses the IO scheduler and creates its own SMTP connection. Which means
- * this is useful when the scheduler is not running.
- *
- * @memberof dc_context_t
- * @param context The context object as returned from dc_context_new().
- * @param chat_id Chat ID to send the message to.
- *     If dc_prepare_msg() was called before, this parameter can be 0.
- * @param msg Message object to send to the chat defined by the chat ID.
- *     On succcess, msg_id of the object is set up,
- *     The function does not take ownership of the object,
- *     so you have to free it using dc_msg_unref() as usual.
- * @return The ID of the message that is about to be sent. 0 in case of errors.
- */
-uint32_t        dc_send_msg_sync                  (dc_context_t* context, uint32_t chat_id, dc_msg_t* msg);
-
 
 /**
  * Send a simple text message a given chat.
@@ -1638,6 +1976,9 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
 
 /**
  * Import/export things.
+ * For this purpose, the function creates a job that is executed in the IMAP-thread then;
+ * this requires to call dc_perform_imap_jobs() regularly.
+ *
  * What to do is defined by the _what_ parameter which may be one of the following:
  *
  * - **DC_IMEX_EXPORT_BACKUP** (11) - Export a backup to the directory given as `param1`.
@@ -2410,6 +2751,7 @@ dc_context_t*    dc_chatlist_get_context     (dc_chatlist_t* chatlist);
  * last-message-date:
  * avatar-path: path-to-blobfile
  * is_verified: yes/no
+
  * @return a utf8-encoded json string containing all requested info. Must be freed using dc_str_unref().  NULL is never returned.
  */
 char*            dc_chat_get_info_json       (dc_context_t* context, size_t chat_id);
@@ -3818,122 +4160,11 @@ int64_t          dc_lot_get_timestamp     (const dc_lot_t* lot);
 #define DC_EMPTY_INBOX 0x02 // Deprecated, flag for dc_empty_server(): Clear all INBOX messages
 
 
-/**
- * @class dc_event_emitter_t
- *
- * Opaque object that is used to get events.
- * You can get an event emitter from a context using dc_get_event_emitter().
- */
-
-/**
- * Get the next event from an event emitter object.
- *
- * @memberof dc_event_emitter_t
- * @param emitter Event emitter object as returned from dc_get_event_emitter().
- * @return An event as an dc_event_t object.
- *     You can query the event for information using dc_event_get_id(), dc_event_get_data1_int() and so on;
- *     if you are done with the event, you have to free the event using dc_event_unref().
- *     If NULL is returned, the context belonging to the event emitter is unref'd and the no more events will come;
- *     in this case, free the event emitter using dc_event_emitter_unref().
- */
-dc_event_t* dc_get_next_event(dc_event_emitter_t* emitter);
-
-
-/**
- * Free an event emitter object.
- *
- * @memberof dc_event_emitter_t
- * @param emitter Event emitter object as returned from dc_get_event_emitter().
- *     If NULL is given, nothing is done and an error is logged.
- * @return None.
- */
-void  dc_event_emitter_unref(dc_event_emitter_t* emitter);
-
-
-/**
- * @class dc_event_t
- *
- * Opaque object describing a single event.
- * To get events, call dc_get_next_event() on an event emitter created by dc_get_event_emitter().
- */
-
-/**
- * Get the event-id from an event object.
- * The event-id is one of the @ref DC_EVENT constants.
- * There may be additional data belonging to an event,
- * to get them, use dc_event_get_data1_int(), dc_event_get_data2_int() and dc_event_get_data2_str().
- *
- * @memberof dc_event_t
- * @param event Event object as returned from dc_get_next_event().
- * @return once of the @ref DC_EVENT constants.
- *     0 on errors.
- */
-int dc_event_get_id(dc_event_t* event);
-
-
-/**
- * Get a data associated with an event object.
- * The meaning of the data depends on the event-id
- * returned as @ref DC_EVENT constants by dc_event_get_id().
- * See also dc_event_get_data2_int() and dc_event_get_data2_str().
- *
- * @memberof dc_event_t
- * @param event Event object as returned from dc_get_next_event().
- * @return "data1" as a signed integer, at least 32bit,
- *     the meaning depends on the event type associated with this event.
- */
-int dc_event_get_data1_int(dc_event_t* event);
-
-
-/**
- * Get a data associated with an event object.
- * The meaning of the data depends on the event-id
- * returned as @ref DC_EVENT constants by dc_event_get_id().
- * See also dc_event_get_data2_int() and dc_event_get_data2_str().
- *
- * @memberof dc_event_t
- * @param event Event object as returned from dc_get_next_event().
- * @return "data2" as a signed integer, at least 32bit,
- *     the meaning depends on the event type associated with this event.
- */
-int dc_event_get_data2_int(dc_event_t* event);
-
-
-/**
- * Get a data associated with an event object.
- * The meaning of the data depends on the event-id
- * returned as @ref DC_EVENT constants by dc_event_get_id().
- * See also dc_event_get_data1_int() and dc_event_get_data2_int().
- *
- * @memberof dc_event_t
- * @param event Event object as returned from dc_get_next_event().
- * @return "data2" as a string,
- *     the meaning depends on the event type associated with this event.
- *     Once you're done with the string, you have to unref it using dc_unref_str().
- */
-char* dc_event_get_data2_str(dc_event_t* event);
-
-
-/**
- * Free memory used by an event object.
- * If you forget to do this for an event, this will result in memory leakage.
- *
- * @memberof dc_event_t
- * @param event Event object as returned from dc_get_next_event().
- * @return None.
- */
-void dc_event_unref(dc_event_t* event);
-
-
 /**
  * @defgroup DC_EVENT DC_EVENT
  *
- * These constants are used as event-id
- * in events returned by dc_get_next_event().
- *
- * Events typically come with some additional data,
- * use dc_event_get_data1_int(), dc_event_get_data2_int() and dc_event_get_data2_str() to read this data.
- * The meaning of the data depends on the event.
+ * These constants are used as events
+ * reported to the callback given to dc_context_new().
  *
  * @addtogroup DC_EVENT
  * @{
@@ -3941,11 +4172,13 @@ void dc_event_unref(dc_event_t* event);
 
 /**
  * The library-user may write an informational string to the log.
+ * Passed to the callback given to dc_context_new().
  *
  * This event should not be reported to the end-user using a popup or something like that.
  *
  * @param data1 0
- * @param data2 (char*) Info string in english language.
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_INFO                     100
 
@@ -3954,7 +4187,8 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when SMTP connection is established and login was successful.
  *
  * @param data1 0
- * @param data2 (char*) Info string in english language.
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_SMTP_CONNECTED           101
 
@@ -3963,7 +4197,8 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when IMAP connection is established and login was successful.
  *
  * @param data1 0
- * @param data2 (char*) Info string in english language.
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_IMAP_CONNECTED           102
 
@@ -3971,7 +4206,8 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when a message was successfully sent to the SMTP server.
  *
  * @param data1 0
- * @param data2 (char*) Info string in english language.
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_SMTP_MESSAGE_SENT        103
 
@@ -3979,7 +4215,8 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when a message was successfully marked as deleted on the IMAP server.
  *
  * @param data1 0
- * @param data2 (char*) Info string in english language.
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_IMAP_MESSAGE_DELETED   104
 
@@ -3987,7 +4224,8 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when a message was successfully moved on IMAP.
  *
  * @param data1 0
- * @param data2 (char*) Info string in english language.
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_IMAP_MESSAGE_MOVED   105
 
@@ -3995,7 +4233,8 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when an IMAP folder was emptied.
  *
  * @param data1 0
- * @param data2 (char*) Folder name.
+ * @param data2 (const char*) folder name.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_IMAP_FOLDER_EMPTIED  106
 
@@ -4003,7 +4242,8 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when a new blob file was successfully written
  *
  * @param data1 0
- * @param data2 (char*) Path name
+ * @param data2 (const char*) path name
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_NEW_BLOB_FILE 150
 
@@ -4011,23 +4251,27 @@ void dc_event_unref(dc_event_t* event);
  * Emitted when a blob file was successfully deleted
  *
  * @param data1 0
- * @param data2 (char*) Path name
+ * @param data2 (const char*) path name
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_DELETED_BLOB_FILE 151
 
 /**
  * The library-user should write a warning string to the log.
+ * Passed to the callback given to dc_context_new().
  *
  * This event should not be reported to the end-user using a popup or something like that.
  *
  * @param data1 0
- * @param data2 (char*) Warning string in english language.
+ * @param data2 (const char*) Warning string in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_WARNING                  300
 
 
 /**
  * The library-user should report an error to the end-user.
+ * Passed to the callback given to dc_context_new().
  *
  * As most things are asynchronous, things may go wrong at any time and the user
  * should not be disturbed by a dialog or so.  Instead, use a bubble or so.
@@ -4039,9 +4283,10 @@ void dc_event_unref(dc_event_t* event);
  * in a messasge box then.
  *
  * @param data1 0
- * @param data2 (char*) Error string, always set, never NULL.
+ * @param data2 (const char*) Error string, always set, never NULL.
  *     Some error strings are taken from dc_set_stock_translation(),
  *     however, most error strings will be in english language.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_ERROR                    400
 
@@ -4063,7 +4308,8 @@ void dc_event_unref(dc_event_t* event);
  *
  * @param data1 (int) 1=first/new network error, should be reported the user;
  *     0=subsequent network error, should be logged only
- * @param data2 (char*) Error string, always set, never NULL.
+ * @param data2 (const char*) Error string, always set, never NULL.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
  */
 #define DC_EVENT_ERROR_NETWORK            401
 
@@ -4076,7 +4322,9 @@ void dc_event_unref(dc_event_t* event);
  * dc_send_text_msg() or another sending function.
  *
  * @param data1 0
- * @param data2 (char*) Info string in english language.
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be unref'd or modified
+ *     and is valid only until the callback returns.
  */
 #define DC_EVENT_ERROR_SELF_NOT_IN_GROUP  410
 
@@ -4194,8 +4442,9 @@ void dc_event_unref(dc_event_t* event);
  * A typical purpose for a handler of this event may be to make the file public to some system
  * services.
  *
- * @param data1 0
- * @param data2 (char*) Path and file name.
+ * @param data1 (const char*) Path and file name.
+ *     Must not be unref'd or modified and is valid only until the callback returns.
+ * @param data2 0
  */
 #define DC_EVENT_IMEX_FILE_WRITTEN        2052
 
@@ -4242,8 +4491,8 @@ void dc_event_unref(dc_event_t* event);
 #define DC_ERROR_SEE_STRING          0    // not used anymore
 #define DC_ERROR_SELF_NOT_IN_GROUP   1    // not used anymore
 #define DC_STR_SELFNOTINGRP          21   // not used anymore
-#define DC_EVENT_DATA1_IS_STRING(e)  0    // not used anymore 
-#define DC_EVENT_DATA2_IS_STRING(e)  ((e)==DC_EVENT_IMEX_FILE_WRITTEN || ((e)>=100 && (e)<=499))
+#define DC_EVENT_DATA1_IS_STRING(e)  ((e)==DC_EVENT_IMEX_FILE_WRITTEN || (e)==DC_EVENT_FILE_COPIED)
+#define DC_EVENT_DATA2_IS_STRING(e)  ((e)>=100 && (e)<=499)
 #define DC_EVENT_RETURNS_INT(e)      ((e)==DC_EVENT_IS_OFFLINE) // not used anymore
 #define DC_EVENT_RETURNS_STRING(e)   ((e)==DC_EVENT_GET_STRING) // not used anymore
 #define dc_archive_chat(a,b,c)  dc_set_chat_visibility((a), (b), (c)? 1 : 0) // not used anymore
@@ -4423,11 +4672,7 @@ void dc_event_unref(dc_event_t* event);
 #define DC_STR_LOCATION                   66
 #define DC_STR_STICKER                    67
 #define DC_STR_DEVICE_MESSAGES            68
-#define DC_STR_SAVED_MESSAGES             69
-#define DC_STR_DEVICE_MESSAGES_HINT       70
-#define DC_STR_WELCOME_MESSAGE            71
-#define DC_STR_UNKNOWN_SENDER_FOR_CHAT    72
-#define DC_STR_COUNT                      72
+#define DC_STR_COUNT                      68
 
 /*
  * @}

examples/repl/cmdline.rs

@@ -1,7 +1,7 @@
+use std::path::Path;
 use std::str::FromStr;
 
 use anyhow::{bail, ensure};
-use async_std::path::Path;
 use deltachat::chat::{self, Chat, ChatId, ChatVisibility};
 use deltachat::chatlist::*;
 use deltachat::constants::*;
@@ -11,6 +11,7 @@ use deltachat::dc_receive_imf::*;
 use deltachat::dc_tools::*;
 use deltachat::error::Error;
 use deltachat::imex::*;
+use deltachat::job::*;
 use deltachat::location;
 use deltachat::lot::LotState;
 use deltachat::message::{self, Message, MessageState, MsgId};
@@ -23,79 +24,78 @@ use deltachat::{config, provider};
 /// Reset database tables.
 /// Argument is a bitmask, executing single or multiple actions in one call.
 /// e.g. bitmask 7 triggers actions definded with bits 1, 2 and 4.
-async fn reset_tables(context: &Context, bits: i32) {
+fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
     println!("Resetting tables ({})...", bits);
     if 0 != bits & 1 {
-        context
-            .sql()
-            .execute("DELETE FROM jobs;", paramsv![])
-            .await
-            .unwrap();
+        sql::execute(context, &context.sql, "DELETE FROM jobs;", params![]).unwrap();
         println!("(1) Jobs reset.");
     }
     if 0 != bits & 2 {
-        context
-            .sql()
-            .execute("DELETE FROM acpeerstates;", paramsv![])
-            .await
-            .unwrap();
+        sql::execute(
+            context,
+            &context.sql,
+            "DELETE FROM acpeerstates;",
+            params![],
+        )
+        .unwrap();
         println!("(2) Peerstates reset.");
     }
     if 0 != bits & 4 {
-        context
-            .sql()
-            .execute("DELETE FROM keypairs;", paramsv![])
-            .await
-            .unwrap();
+        sql::execute(context, &context.sql, "DELETE FROM keypairs;", params![]).unwrap();
         println!("(4) Private keypairs reset.");
     }
     if 0 != bits & 8 {
-        context
-            .sql()
-            .execute("DELETE FROM contacts WHERE id>9;", paramsv![])
-            .await
-            .unwrap();
-        context
-            .sql()
-            .execute("DELETE FROM chats WHERE id>9;", paramsv![])
-            .await
-            .unwrap();
-        context
-            .sql()
-            .execute("DELETE FROM chats_contacts;", paramsv![])
-            .await
-            .unwrap();
-        context
-            .sql()
-            .execute("DELETE FROM msgs WHERE id>9;", paramsv![])
-            .await
-            .unwrap();
-        context
-            .sql()
-            .execute(
-                "DELETE FROM config WHERE keyname LIKE 'imap.%' OR keyname LIKE 'configured%';",
-                paramsv![],
-            )
-            .await
-            .unwrap();
-        context
-            .sql()
-            .execute("DELETE FROM leftgrps;", paramsv![])
-            .await
-            .unwrap();
+        sql::execute(
+            context,
+            &context.sql,
+            "DELETE FROM contacts WHERE id>9;",
+            params![],
+        )
+        .unwrap();
+        sql::execute(
+            context,
+            &context.sql,
+            "DELETE FROM chats WHERE id>9;",
+            params![],
+        )
+        .unwrap();
+        sql::execute(
+            context,
+            &context.sql,
+            "DELETE FROM chats_contacts;",
+            params![],
+        )
+        .unwrap();
+        sql::execute(
+            context,
+            &context.sql,
+            "DELETE FROM msgs WHERE id>9;",
+            params![],
+        )
+        .unwrap();
+        sql::execute(
+            context,
+            &context.sql,
+            "DELETE FROM config WHERE keyname LIKE 'imap.%' OR keyname LIKE 'configured%';",
+            params![],
+        )
+        .unwrap();
+        sql::execute(context, &context.sql, "DELETE FROM leftgrps;", params![]).unwrap();
         println!("(8) Rest but server config reset.");
     }
 
-    context.emit_event(Event::MsgsChanged {
+    context.call_cb(Event::MsgsChanged {
         chat_id: ChatId::new(0),
         msg_id: MsgId::new(0),
     });
+
+    1
 }
 
-async fn poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<(), anyhow::Error> {
-    let data = dc_read_file(context, filename).await?;
+fn dc_poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<(), anyhow::Error> {
+    let data = dc_read_file(context, filename)?;
 
-    if let Err(err) = dc_receive_imf(context, &data, "import", 0, false).await {
+    if let Err(err) = dc_receive_imf(context, &data, "import", 0, false) {
         println!("dc_receive_imf errored: {:?}", err);
     }
     Ok(())
@@ -104,29 +104,38 @@ async fn poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<
 /// Import a file to the database.
 /// For testing, import a folder with eml-files, a single eml-file, e-mail plus public key and so on.
 /// For normal importing, use imex().
-async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
-    let mut read_cnt: usize = 0;
+///
+/// @private @memberof Context
+/// @param context The context as created by dc_context_new().
+/// @param spec The file or directory to import. NULL for the last command.
+/// @return 1=success, 0=error.
+fn poke_spec(context: &Context, spec: Option<&str>) -> libc::c_int {
+    if !context.sql.is_open() {
+        error!(context, "Import: Database not opened.");
+        return 0;
+    }
+
+    let mut read_cnt = 0;
 
     let real_spec: String;
 
-    // if `spec` is given, remember it for later usage; if it is not given, try to use the last one
+    /* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */
     if let Some(spec) = spec {
         real_spec = spec.to_string();
         context
-            .sql()
+            .sql
             .set_raw_config(context, "import_spec", Some(&real_spec))
-            .await
             .unwrap();
     } else {
-        let rs = context.sql().get_raw_config(context, "import_spec").await;
+        let rs = context.sql.get_raw_config(context, "import_spec");
         if rs.is_none() {
             error!(context, "Import: No file or folder given.");
-            return false;
+            return 0;
         }
         real_spec = rs.unwrap();
     }
     if let Some(suffix) = dc_get_filesuffix_lc(&real_spec) {
-        if suffix == "eml" && poke_eml_file(context, &real_spec).await.is_ok() {
+        if suffix == "eml" && dc_poke_eml_file(context, &real_spec).is_ok() {
             read_cnt += 1
         }
     } else {
@@ -135,7 +144,7 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
         let dir = std::fs::read_dir(dir_name);
         if dir.is_err() {
             error!(context, "Import: Cannot open directory \"{}\".", &real_spec,);
-            return false;
+            return 0;
         } else {
             let dir = dir.unwrap();
             for entry in dir {
@@ -148,7 +157,7 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
                 if name.ends_with(".eml") {
                     let path_plus_name = format!("{}/{}", &real_spec, name);
                     println!("Import: {}", path_plus_name);
-                    if poke_eml_file(context, path_plus_name).await.is_ok() {
+                    if dc_poke_eml_file(context, path_plus_name).is_ok() {
                         read_cnt += 1
                     }
                 }
@@ -157,19 +166,16 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
     }
     println!("Import: {} items read from \"{}\".", read_cnt, &real_spec);
     if read_cnt > 0 {
-        context.emit_event(Event::MsgsChanged {
+        context.call_cb(Event::MsgsChanged {
             chat_id: ChatId::new(0),
             msg_id: MsgId::new(0),
         });
     }
-    true
+    1
 }
 
-async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
-    let contact = Contact::get_by_id(context, msg.get_from_id())
-        .await
-        .expect("invalid contact");
-
+fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
+    let contact = Contact::get_by_id(context, msg.get_from_id()).expect("invalid contact");
     let contact_name = contact.get_name();
     let contact_id = contact.get_id();
 
@@ -212,7 +218,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
     );
 }
 
-async fn log_msglist(context: &Context, msglist: &[MsgId]) -> Result<(), Error> {
+fn log_msglist(context: &Context, msglist: &Vec<MsgId>) -> Result<(), Error> {
     let mut lines_out = 0;
     for &msg_id in msglist {
         if msg_id.is_daymarker() {
@@ -228,8 +234,8 @@ async fn log_msglist(context: &Context, msglist: &[MsgId]) -> Result<(), Error>
                 );
                 lines_out += 1
             }
-            let msg = Message::load_from_db(context, msg_id).await?;
-            log_msg(context, "", &msg).await;
+            let msg = Message::load_from_db(context, msg_id)?;
+            log_msg(context, "", &msg);
         }
     }
     if lines_out > 0 {
@@ -240,18 +246,18 @@ async fn log_msglist(context: &Context, msglist: &[MsgId]) -> Result<(), Error>
     Ok(())
 }
 
-async fn log_contactlist(context: &Context, contacts: &[u32]) {
-    let mut contacts = contacts.to_vec();
+fn log_contactlist(context: &Context, contacts: &Vec<u32>) {
+    let mut contacts = contacts.clone();
     if !contacts.contains(&1) {
         contacts.push(1);
     }
     for contact_id in contacts {
         let line;
         let mut line2 = "".to_string();
-        if let Ok(contact) = Contact::get_by_id(context, contact_id).await {
+        if let Ok(contact) = Contact::get_by_id(context, contact_id) {
             let name = contact.get_name();
             let addr = contact.get_addr();
-            let verified_state = contact.is_verified(context).await;
+            let verified_state = contact.is_verified(context);
             let verified_str = if VerifiedStatus::Unverified != verified_state {
                 if verified_state == VerifiedStatus::BidirectVerified {
                     " √√"
@@ -275,7 +281,7 @@ async fn log_contactlist(context: &Context, contacts: &[u32]) {
                     "addr unset"
                 }
             );
-            let peerstate = Peerstate::from_addr(context, &addr).await;
+            let peerstate = Peerstate::from_addr(context, &context.sql, &addr);
             if peerstate.is_some() && contact_id != 1 as libc::c_uint {
                 line2 = format!(
                     ", prefer-encrypt={}",
@@ -292,9 +298,10 @@ fn chat_prefix(chat: &Chat) -> &'static str {
     chat.typ.into()
 }
 
-pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Result<(), Error> {
+pub fn dc_cmdline(context: &Context, line: &str) -> Result<(), Error> {
+    let chat_id = *context.cmdline_sel_chat_id.read().unwrap();
     let mut sel_chat = if !chat_id.is_unset() {
-        Chat::load_from_db(&context, *chat_id).await.ok()
+        Chat::load_from_db(context, chat_id).ok()
     } else {
         None
     };
@@ -335,6 +342,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                  configure\n\
                  connect\n\
                  disconnect\n\
+                 interrupt\n\
                  maybenetwork\n\
                  housekeeping\n\
                  help imex (Import/Export)\n\
@@ -397,7 +405,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                  ============================================="
             ),
         },
-        "initiate-key-transfer" => match initiate_key_transfer(&context).await {
+        "initiate-key-transfer" => match initiate_key_transfer(context) {
             Ok(setup_code) => println!(
                 "Setup code for the transferred setup message: {}",
                 setup_code,
@@ -407,9 +415,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         "get-setupcodebegin" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
             let msg_id: MsgId = MsgId::new(arg1.parse()?);
-            let msg = Message::load_from_db(&context, msg_id).await?;
+            let msg = Message::load_from_db(context, msg_id)?;
             if msg.is_setupmessage() {
-                let setupcodebegin = msg.get_setupcodebegin(&context).await;
+                let setupcodebegin = msg.get_setupcodebegin(context);
                 println!(
                     "The setup code for setup message {} starts with: {}",
                     msg_id,
@@ -424,29 +432,29 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 !arg1.is_empty() && !arg2.is_empty(),
                 "Arguments <msg-id> <setup-code> expected"
             );
-            continue_key_transfer(&context, MsgId::new(arg1.parse()?), &arg2).await?;
+            continue_key_transfer(context, MsgId::new(arg1.parse()?), &arg2)?;
         }
         "has-backup" => {
-            has_backup(&context, blobdir).await?;
+            has_backup(context, blobdir)?;
         }
         "export-backup" => {
-            imex(&context, ImexMode::ExportBackup, Some(blobdir)).await?;
+            imex(context, ImexMode::ExportBackup, Some(blobdir));
         }
         "import-backup" => {
             ensure!(!arg1.is_empty(), "Argument <backup-file> missing.");
-            imex(&context, ImexMode::ImportBackup, Some(arg1)).await?;
+            imex(context, ImexMode::ImportBackup, Some(arg1));
         }
         "export-keys" => {
-            imex(&context, ImexMode::ExportSelfKeys, Some(blobdir)).await?;
+            imex(context, ImexMode::ExportSelfKeys, Some(blobdir));
         }
         "import-keys" => {
-            imex(&context, ImexMode::ImportSelfKeys, Some(blobdir)).await?;
+            imex(context, ImexMode::ImportSelfKeys, Some(blobdir));
         }
         "export-setup" => {
-            let setup_code = create_setup_code(&context);
+            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?;
+            let file_content = render_setup_file(context, &setup_code)?;
+            std::fs::write(&file_name, file_content)?;
             println!(
                 "Setup message written to: {}\nSetup code: {}",
                 file_name.display(),
@@ -454,47 +462,49 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             );
         }
         "poke" => {
-            ensure!(poke_spec(&context, Some(arg1)).await, "Poke failed");
+            ensure!(0 != poke_spec(context, Some(arg1)), "Poke failed");
         }
         "reset" => {
             ensure!(!arg1.is_empty(), "Argument <bits> missing: 1=jobs, 2=peerstates, 4=private keys, 8=rest but server config");
             let bits: i32 = arg1.parse()?;
             ensure!(bits < 16, "<bits> must be lower than 16.");
-            reset_tables(&context, bits).await;
+            ensure!(0 != dc_reset_tables(context, bits), "Reset failed");
         }
         "stop" => {
-            context.stop_ongoing().await;
+            context.stop_ongoing();
         }
         "set" => {
             ensure!(!arg1.is_empty(), "Argument <key> missing.");
             let key = config::Config::from_str(&arg1)?;
             let value = if arg2.is_empty() { None } else { Some(arg2) };
-            context.set_config(key, value).await?;
+            context.set_config(key, value)?;
         }
         "get" => {
             ensure!(!arg1.is_empty(), "Argument <key> missing.");
             let key = config::Config::from_str(&arg1)?;
-            let val = context.get_config(key).await;
+            let val = context.get_config(key);
             println!("{}={:?}", key, val);
         }
         "info" => {
-            println!("{:#?}", context.get_info().await);
+            println!("{:#?}", context.get_info());
+        }
+        "interrupt" => {
+            interrupt_inbox_idle(context);
         }
         "maybenetwork" => {
-            context.maybe_network().await;
+            maybe_network(context);
         }
         "housekeeping" => {
-            sql::housekeeping(&context).await;
+            sql::housekeeping(context);
         }
         "listchats" | "listarchived" | "chats" => {
             let listflags = if arg0 == "listarchived" { 0x01 } else { 0 };
             let chatlist = Chatlist::try_load(
-                &context,
+                context,
                 listflags,
                 if arg1.is_empty() { None } else { Some(arg1) },
                 None,
-            )
-            .await?;
+            )?;
 
             let cnt = chatlist.len();
             if cnt > 0 {
@@ -503,20 +513,20 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 );
 
                 for i in (0..cnt).rev() {
-                    let chat = Chat::load_from_db(&context, chatlist.get_chat_id(i)).await?;
+                    let chat = Chat::load_from_db(context, chatlist.get_chat_id(i))?;
                     println!(
                         "{}#{}: {} [{} fresh] {}",
                         chat_prefix(&chat),
                         chat.get_id(),
                         chat.get_name(),
-                        chat.get_id().get_fresh_msg_cnt(&context).await,
+                        chat.get_id().get_fresh_msg_cnt(context),
                         match chat.visibility {
                             ChatVisibility::Normal => "",
                             ChatVisibility::Archived => "📦",
                             ChatVisibility::Pinned => "📌",
                         },
                     );
-                    let lot = chatlist.get_summary(&context, i, Some(&chat)).await;
+                    let lot = chatlist.get_summary(context, i, Some(&chat));
                     let statestr = if chat.visibility == ChatVisibility::Archived {
                         " [Archived]"
                     } else {
@@ -549,7 +559,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                     );
                 }
             }
-            if location::is_sending_locations_to_chat(&context, ChatId::new(0)).await {
+            if location::is_sending_locations_to_chat(context, ChatId::new(0)) {
                 println!("Location streaming enabled.");
             }
             println!("{} chats", cnt);
@@ -559,21 +569,21 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 bail!("Argument [chat-id] is missing.");
             }
             if !arg1.is_empty() {
-                let id = ChatId::new(arg1.parse()?);
-                println!("Selecting chat {}", id);
-                sel_chat = Some(Chat::load_from_db(&context, id).await?);
-                *chat_id = id;
+                let chat_id = ChatId::new(arg1.parse()?);
+                println!("Selecting chat {}", chat_id);
+                sel_chat = Some(Chat::load_from_db(context, chat_id)?);
+                *context.cmdline_sel_chat_id.write().unwrap() = chat_id;
             }
 
             ensure!(sel_chat.is_some(), "Failed to select chat");
             let sel_chat = sel_chat.as_ref().unwrap();
 
-            let msglist = chat::get_chat_msgs(&context, sel_chat.get_id(), 0x1, None).await;
-            let members = chat::get_chat_contacts(&context, sel_chat.id).await;
+            let msglist = chat::get_chat_msgs(context, sel_chat.get_id(), 0x1, None);
+            let members = chat::get_chat_contacts(context, sel_chat.id);
             let subtitle = if sel_chat.is_device_talk() {
                 "device-talk".to_string()
             } else if sel_chat.get_type() == Chattype::Single && !members.is_empty() {
-                let contact = Contact::get_by_id(&context, members[0]).await?;
+                let contact = Contact::get_by_id(context, members[0])?;
                 contact.get_addr().to_string()
             } else {
                 format!("{} member(s)", members.len())
@@ -589,7 +599,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 } else {
                     ""
                 },
-                match sel_chat.get_profile_image(&context).await {
+                match sel_chat.get_profile_image(context) {
                     Some(icon) => match icon.to_str() {
                         Some(icon) => format!(" Icon: {}", icon),
                         _ => " Icon: Err".to_string(),
@@ -597,42 +607,38 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                     _ => "".to_string(),
                 },
             );
-            log_msglist(&context, &msglist).await?;
-            if let Some(draft) = sel_chat.get_id().get_draft(&context).await? {
-                log_msg(&context, "Draft", &draft).await;
+            log_msglist(context, &msglist)?;
+            if let Some(draft) = sel_chat.get_id().get_draft(context)? {
+                log_msg(context, "Draft", &draft);
             }
 
-            println!(
-                "{} messages.",
-                sel_chat.get_id().get_msg_cnt(&context).await
-            );
-            chat::marknoticed_chat(&context, sel_chat.get_id()).await?;
+            println!("{} messages.", sel_chat.get_id().get_msg_cnt(context));
+            chat::marknoticed_chat(context, sel_chat.get_id())?;
         }
         "createchat" => {
             ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
             let contact_id: libc::c_int = arg1.parse()?;
-            let chat_id = chat::create_by_contact_id(&context, contact_id as u32).await?;
+            let chat_id = chat::create_by_contact_id(context, contact_id as u32)?;
 
             println!("Single#{} created successfully.", chat_id,);
         }
         "createchatbymsg" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing");
             let msg_id = MsgId::new(arg1.parse()?);
-            let chat_id = chat::create_by_msg_id(&context, msg_id).await?;
-            let chat = Chat::load_from_db(&context, chat_id).await?;
+            let chat_id = chat::create_by_msg_id(context, msg_id)?;
+            let chat = Chat::load_from_db(context, chat_id)?;
 
             println!("{}#{} created successfully.", chat_prefix(&chat), chat_id,);
         }
         "creategroup" => {
             ensure!(!arg1.is_empty(), "Argument <name> missing.");
-            let chat_id =
-                chat::create_group_chat(&context, VerifiedStatus::Unverified, arg1).await?;
+            let chat_id = chat::create_group_chat(context, VerifiedStatus::Unverified, arg1)?;
 
             println!("Group#{} created successfully.", chat_id);
         }
         "createverified" => {
             ensure!(!arg1.is_empty(), "Argument <name> missing.");
-            let chat_id = chat::create_group_chat(&context, VerifiedStatus::Verified, arg1).await?;
+            let chat_id = chat::create_group_chat(context, VerifiedStatus::Verified, arg1)?;
 
             println!("VerifiedGroup#{} created successfully.", chat_id);
         }
@@ -642,12 +648,10 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
 
             let contact_id_0: libc::c_int = arg1.parse()?;
             if chat::add_contact_to_chat(
-                &context,
+                context,
                 sel_chat.as_ref().unwrap().get_id(),
                 contact_id_0 as u32,
-            )
-            .await
-            {
+            ) {
                 println!("Contact added to chat.");
             } else {
                 bail!("Cannot add contact to chat.");
@@ -658,18 +662,17 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
             let contact_id_1: libc::c_int = arg1.parse()?;
             chat::remove_contact_from_chat(
-                &context,
+                context,
                 sel_chat.as_ref().unwrap().get_id(),
                 contact_id_1 as u32,
-            )
-            .await?;
+            )?;
 
             println!("Contact added to chat.");
         }
         "groupname" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
             ensure!(!arg1.is_empty(), "Argument <name> missing.");
-            chat::set_chat_name(&context, sel_chat.as_ref().unwrap().get_id(), arg1).await?;
+            chat::set_chat_name(context, sel_chat.as_ref().unwrap().get_id(), arg1)?;
 
             println!("Chat name set");
         }
@@ -677,27 +680,24 @@ 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(), "Argument <image> missing.");
 
-            chat::set_chat_profile_image(&context, sel_chat.as_ref().unwrap().get_id(), arg1)
-                .await?;
+            chat::set_chat_profile_image(context, sel_chat.as_ref().unwrap().get_id(), arg1)?;
 
             println!("Chat image set");
         }
         "chatinfo" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
 
-            let contacts =
-                chat::get_chat_contacts(&context, sel_chat.as_ref().unwrap().get_id()).await;
+            let contacts = chat::get_chat_contacts(context, sel_chat.as_ref().unwrap().get_id());
             println!("Memberlist:");
 
-            log_contactlist(&context, &contacts).await;
+            log_contactlist(context, &contacts);
             println!(
                 "{} contacts\nLocation streaming: {}",
                 contacts.len(),
                 location::is_sending_locations_to_chat(
-                    &context,
+                    context,
                     sel_chat.as_ref().unwrap().get_id()
-                )
-                .await,
+                ),
             );
         }
         "getlocations" => {
@@ -705,13 +705,12 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
 
             let contact_id = arg1.parse().unwrap_or_default();
             let locations = location::get_range(
-                &context,
+                context,
                 sel_chat.as_ref().unwrap().get_id(),
                 contact_id,
                 0,
                 0,
-            )
-            .await;
+            );
             let default_marker = "-".to_string();
             for location in &locations {
                 let marker = location.marker.as_ref().unwrap_or(&default_marker);
@@ -737,12 +736,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             ensure!(!arg1.is_empty(), "No timeout given.");
 
             let seconds = arg1.parse()?;
-            location::send_locations_to_chat(
-                &context,
-                sel_chat.as_ref().unwrap().get_id(),
-                seconds,
-            )
-            .await;
+            location::send_locations_to_chat(context, sel_chat.as_ref().unwrap().get_id(), seconds);
             println!(
                 "Locations will be sent to Chat#{} for {} seconds. Use 'setlocation <lat> <lng>' to play around.",
                 sel_chat.as_ref().unwrap().get_id(),
@@ -757,7 +751,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let latitude = arg1.parse()?;
             let longitude = arg2.parse()?;
 
-            let continue_streaming = location::set(&context, latitude, longitude, 0.).await;
+            let continue_streaming = location::set(context, latitude, longitude, 0.);
             if continue_streaming {
                 println!("Success, streaming should be continued.");
             } else {
@@ -765,7 +759,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             }
         }
         "dellocations" => {
-            location::delete_all(&context).await?;
+            location::delete_all(context)?;
         }
         "send" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
@@ -773,11 +767,11 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
 
             let msg = format!("{} {}", arg1, arg2);
 
-            chat::send_text_msg(&context, sel_chat.as_ref().unwrap().get_id(), msg).await?;
+            chat::send_text_msg(context, sel_chat.as_ref().unwrap().get_id(), msg)?;
         }
         "sendempty" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
-            chat::send_text_msg(&context, sel_chat.as_ref().unwrap().get_id(), "".into()).await?;
+            chat::send_text_msg(context, sel_chat.as_ref().unwrap().get_id(), "".into())?;
         }
         "sendimage" | "sendfile" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
@@ -792,7 +786,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             if !arg2.is_empty() {
                 msg.set_text(Some(arg2.to_string()));
             }
-            chat::send_msg(&context, sel_chat.as_ref().unwrap().get_id(), &mut msg).await?;
+            chat::send_msg(context, sel_chat.as_ref().unwrap().get_id(), &mut msg)?;
         }
         "listmsgs" => {
             ensure!(!arg1.is_empty(), "Argument <query> missing.");
@@ -803,9 +797,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                 ChatId::new(0)
             };
 
-            let msglist = context.search_msgs(chat, arg1).await;
+            let msglist = context.search_msgs(chat, arg1);
 
-            log_msglist(&context, &msglist).await?;
+            log_msglist(context, &msglist)?;
             println!("{} messages.", msglist.len());
         }
         "draft" => {
@@ -818,16 +812,10 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                     .as_ref()
                     .unwrap()
                     .get_id()
-                    .set_draft(&context, Some(&mut draft))
-                    .await;
+                    .set_draft(context, Some(&mut draft));
                 println!("Draft saved.");
             } else {
-                sel_chat
-                    .as_ref()
-                    .unwrap()
-                    .get_id()
-                    .set_draft(&context, None)
-                    .await;
+                sel_chat.as_ref().unwrap().get_id().set_draft(context, None);
                 println!("Draft deleted.");
             }
         }
@@ -838,22 +826,21 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             );
             let mut msg = Message::new(Viewtype::Text);
             msg.set_text(Some(arg1.to_string()));
-            chat::add_device_msg(&context, None, Some(&mut msg)).await?;
+            chat::add_device_msg(context, None, Some(&mut msg))?;
         }
         "updatedevicechats" => {
-            context.update_device_chats().await?;
+            context.update_device_chats()?;
         }
         "listmedia" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
 
             let images = chat::get_chat_media(
-                &context,
+                context,
                 sel_chat.as_ref().unwrap().get_id(),
                 Viewtype::Image,
                 Viewtype::Gif,
                 Viewtype::Video,
-            )
-            .await;
+            );
             println!("{} images or videos: ", images.len());
             for (i, data) in images.iter().enumerate() {
                 if 0 == i {
@@ -862,38 +849,36 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                     print!(", {}", data);
                 }
             }
-            println!();
+            print!("\n");
         }
         "archive" | "unarchive" | "pin" | "unpin" => {
             ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
             let chat_id = ChatId::new(arg1.parse()?);
-            chat_id
-                .set_visibility(
-                    &context,
-                    match arg0 {
-                        "archive" => ChatVisibility::Archived,
-                        "unarchive" | "unpin" => ChatVisibility::Normal,
-                        "pin" => ChatVisibility::Pinned,
-                        _ => panic!("Unexpected command (This should never happen)"),
-                    },
-                )
-                .await?;
+            chat_id.set_visibility(
+                context,
+                match arg0 {
+                    "archive" => ChatVisibility::Archived,
+                    "unarchive" | "unpin" => ChatVisibility::Normal,
+                    "pin" => ChatVisibility::Pinned,
+                    _ => panic!("Unexpected command (This should never happen)"),
+                },
+            )?;
         }
         "delchat" => {
             ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
             let chat_id = ChatId::new(arg1.parse()?);
-            chat_id.delete(&context).await?;
+            chat_id.delete(context)?;
         }
         "msginfo" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
             let id = MsgId::new(arg1.parse()?);
-            let res = message::get_msg_info(&context, id).await;
+            let res = message::get_msg_info(context, id);
             println!("{}", res);
         }
         "listfresh" => {
-            let msglist = context.get_fresh_msgs().await;
+            let msglist = context.get_fresh_msgs();
 
-            log_msglist(&context, &msglist).await?;
+            log_msglist(context, &msglist)?;
             print!("{} fresh messages.", msglist.len());
         }
         "forward" => {
@@ -905,38 +890,37 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             let mut msg_ids = [MsgId::new(0); 1];
             let chat_id = ChatId::new(arg2.parse()?);
             msg_ids[0] = MsgId::new(arg1.parse()?);
-            chat::forward_msgs(&context, &msg_ids, chat_id).await?;
+            chat::forward_msgs(context, &msg_ids, chat_id)?;
         }
         "markseen" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
-            let mut msg_ids = vec![MsgId::new(0)];
+            let mut msg_ids = [MsgId::new(0); 1];
             msg_ids[0] = MsgId::new(arg1.parse()?);
-            message::markseen_msgs(&context, msg_ids).await;
+            message::markseen_msgs(context, &msg_ids);
         }
         "star" | "unstar" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
-            let mut msg_ids = vec![MsgId::new(0); 1];
+            let mut msg_ids = [MsgId::new(0); 1];
             msg_ids[0] = MsgId::new(arg1.parse()?);
-            message::star_msgs(&context, msg_ids, arg0 == "star").await;
+            message::star_msgs(context, &msg_ids, arg0 == "star");
         }
         "delmsg" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
             let mut ids = [MsgId::new(0); 1];
             ids[0] = MsgId::new(arg1.parse()?);
-            message::delete_msgs(&context, &ids).await;
+            message::delete_msgs(context, &ids);
         }
         "listcontacts" | "contacts" | "listverified" => {
             let contacts = Contact::get_all(
-                &context,
+                context,
                 if arg0 == "listverified" {
                     0x1 | 0x2
                 } else {
                     0x2
                 },
                 Some(arg1),
-            )
-            .await?;
-            log_contactlist(&context, &contacts).await;
+            )?;
+            log_contactlist(context, &contacts);
             println!("{} contacts.", contacts.len());
         }
         "addcontact" => {
@@ -944,30 +928,30 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
 
             if !arg2.is_empty() {
                 let book = format!("{}\n{}", arg1, arg2);
-                Contact::add_address_book(&context, book).await?;
+                Contact::add_address_book(context, book)?;
             } else {
-                Contact::create(&context, "", arg1).await?;
+                Contact::create(context, "", arg1)?;
             }
         }
         "contactinfo" => {
             ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
 
             let contact_id = arg1.parse()?;
-            let contact = Contact::get_by_id(&context, contact_id).await?;
+            let contact = Contact::get_by_id(context, contact_id)?;
             let name_n_addr = contact.get_name_n_addr();
 
             let mut res = format!(
                 "Contact info for: {}:\nIcon: {}\n",
                 name_n_addr,
-                match contact.get_profile_image(&context).await {
+                match contact.get_profile_image(context) {
                     Some(image) => image.to_str().unwrap().to_string(),
                     None => "NoIcon".to_string(),
                 }
             );
 
-            res += &Contact::get_encrinfo(&context, contact_id).await?;
+            res += &Contact::get_encrinfo(context, contact_id)?;
 
-            let chatlist = Chatlist::try_load(&context, 0, None, Some(contact_id)).await?;
+            let chatlist = Chatlist::try_load(context, 0, None, Some(contact_id))?;
             let chatlist_cnt = chatlist.len();
             if chatlist_cnt > 0 {
                 res += &format!(
@@ -978,7 +962,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                     if 0 != i {
                         res += ", ";
                     }
-                    let chat = Chat::load_from_db(&context, chatlist.get_chat_id(i)).await?;
+                    let chat = Chat::load_from_db(context, chatlist.get_chat_id(i))?;
                     res += &format!("{}#{}", chat_prefix(&chat), chat.get_id());
                 }
             }
@@ -987,11 +971,11 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         }
         "delcontact" => {
             ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
-            Contact::delete(&context, arg1.parse()?).await?;
+            Contact::delete(context, arg1.parse()?)?;
         }
         "checkqr" => {
             ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");
-            let res = check_qr(&context, arg1).await;
+            let res = check_qr(context, arg1);
             println!(
                 "state={}, id={}, text1={:?}, text2={:?}",
                 res.get_state(),
@@ -1002,7 +986,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         }
         "setqr" => {
             ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");
-            match set_config_from_qr(&context, arg1).await {
+            match set_config_from_qr(context, arg1) {
                 Ok(()) => println!("Config set from QR code, you can now call 'configure'"),
                 Err(err) => println!("Cannot set config from QR code: {:?}", err),
             }
@@ -1030,7 +1014,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         //     ensure!(!arg1.is_empty(), "Argument <id> missing.");
         //     let event = arg1.parse()?;
         //     let event = Event::from_u32(event).ok_or(format_err!("Event::from_u32({})", event))?;
-        //     let r = context.emit_event(event, 0 as libc::uintptr_t, 0 as libc::uintptr_t);
+        //     let r = context.call_cb(event, 0 as libc::uintptr_t, 0 as libc::uintptr_t);
         //     println!(
         //         "Sending event {:?}({}), received value {}.",
         //         event, event as usize, r as libc::c_int,
@@ -1039,7 +1023,7 @@ 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 {
+            if let Ok(buf) = dc_read_file(context, &arg1) {
                 let (width, height) = dc_get_filemeta(&buf)?;
                 println!("width={}, height={}", width, height);
             } else {
@@ -1049,8 +1033,8 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         "estimatedeletion" => {
             ensure!(!arg1.is_empty(), "Argument <seconds> missing");
             let seconds = arg1.parse()?;
-            let device_cnt = message::estimate_deletion_cnt(&context, false, seconds).await?;
-            let server_cnt = message::estimate_deletion_cnt(&context, true, seconds).await?;
+            let device_cnt = message::estimate_deletion_cnt(context, false, seconds)?;
+            let server_cnt = message::estimate_deletion_cnt(context, true, seconds)?;
             println!(
                 "estimated count of messages older than {} seconds:\non device: {}\non server: {}",
                 seconds, device_cnt, server_cnt
@@ -1059,7 +1043,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         "emptyserver" => {
             ensure!(!arg1.is_empty(), "Argument <flags> missing");
 
-            message::dc_empty_server(&context, arg1.parse()?).await;
+            message::dc_empty_server(context, arg1.parse()?);
         }
         "" => (),
         _ => bail!("Unknown command: \"{}\" type ? for help.", arg0),

examples/repl/main.rs

@@ -6,17 +6,23 @@
 
 #[macro_use]
 extern crate deltachat;
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate rusqlite;
 
 use std::borrow::Cow::{self, Borrowed, Owned};
 use std::io::{self, Write};
+use std::path::Path;
 use std::process::Command;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, RwLock};
 
-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::job::*;
 use deltachat::oauth2::*;
 use deltachat::securejoin::*;
 use deltachat::Event;
@@ -32,83 +38,179 @@ use rustyline::{
 mod cmdline;
 use self::cmdline::*;
 
-/// Event Handler
-fn receive_event(event: Event) {
-    let yellow = Color::Yellow.normal();
-    let red = Color::Red.normal();
+// Event Handler
+
+fn receive_event(_context: &Context, event: Event) {
     match event {
         Event::Info(msg) => {
-            println!("[INFO] {}", msg);
+            /* do not show the event as this would fill the screen */
+            println!("{}", msg);
         }
         Event::SmtpConnected(msg) => {
-            println!("[INFO SMTP_CONNECTED] {}", msg);
+            println!("[DC_EVENT_SMTP_CONNECTED] {}", msg);
         }
         Event::ImapConnected(msg) => {
-            println!("[INFO IMAP_CONNECTED] {}", msg);
+            println!("[DC_EVENT_IMAP_CONNECTED] {}", msg);
         }
         Event::SmtpMessageSent(msg) => {
-            println!("[INFO SMTP_MESSAGE_SENT] {}", msg);
+            println!("[DC_EVENT_SMTP_MESSAGE_SENT] {}", msg);
         }
         Event::Warning(msg) => {
-            println!("[WARNING] {}", msg);
+            println!("[Warning] {}", msg);
         }
         Event::Error(msg) => {
-            println!("[ERROR] {}", red.paint(msg));
+            println!("\x1b[31m[DC_EVENT_ERROR] {}\x1b[0m", msg);
         }
         Event::ErrorNetwork(msg) => {
-            println!("[ERROR NETWORK] msg={}", red.paint(msg));
+            println!("\x1b[31m[DC_EVENT_ERROR_NETWORK] msg={}\x1b[0m", msg);
         }
         Event::ErrorSelfNotInGroup(msg) => {
-            println!("[ERROR SELF_NOT_IN_GROUP] {}", red.paint(msg));
+            println!("\x1b[31m[DC_EVENT_ERROR_SELF_NOT_IN_GROUP] {}\x1b[0m", msg);
         }
         Event::MsgsChanged { chat_id, msg_id } => {
-            println!(
-                "{}",
-                yellow.paint(format!(
-                    "Received MSGS_CHANGED(chat_id={}, msg_id={})",
-                    chat_id, msg_id,
-                ))
+            print!(
+                "\x1b[33m{{Received DC_EVENT_MSGS_CHANGED(chat_id={}, msg_id={})}}\n\x1b[0m",
+                chat_id, msg_id,
             );
         }
         Event::ContactsChanged(_) => {
-            println!("{}", yellow.paint("Received CONTACTS_CHANGED()"));
+            print!("\x1b[33m{{Received DC_EVENT_CONTACTS_CHANGED()}}\n\x1b[0m");
         }
         Event::LocationChanged(contact) => {
-            println!(
-                "{}",
-                yellow.paint(format!("Received LOCATION_CHANGED(contact={:?})", contact))
+            print!(
+                "\x1b[33m{{Received DC_EVENT_LOCATION_CHANGED(contact={:?})}}\n\x1b[0m",
+                contact,
             );
         }
         Event::ConfigureProgress(progress) => {
-            println!(
-                "{}",
-                yellow.paint(format!("Received CONFIGURE_PROGRESS({} ‰)", progress))
+            print!(
+                "\x1b[33m{{Received DC_EVENT_CONFIGURE_PROGRESS({} ‰)}}\n\x1b[0m",
+                progress,
             );
         }
         Event::ImexProgress(progress) => {
-            println!(
-                "{}",
-                yellow.paint(format!("Received IMEX_PROGRESS({} ‰)", progress))
+            print!(
+                "\x1b[33m{{Received DC_EVENT_IMEX_PROGRESS({} ‰)}}\n\x1b[0m",
+                progress,
             );
         }
         Event::ImexFileWritten(file) => {
-            println!(
-                "{}",
-                yellow.paint(format!("Received IMEX_FILE_WRITTEN({})", file.display()))
+            print!(
+                "\x1b[33m{{Received DC_EVENT_IMEX_FILE_WRITTEN({})}}\n\x1b[0m",
+                file.display()
             );
         }
         Event::ChatModified(chat) => {
-            println!(
-                "{}",
-                yellow.paint(format!("Received CHAT_MODIFIED({})", chat))
+            print!(
+                "\x1b[33m{{Received DC_EVENT_CHAT_MODIFIED({})}}\n\x1b[0m",
+                chat
             );
         }
         _ => {
-            println!("Received {}", yellow.paint(format!("{:?}", event)));
+            print!("\x1b[33m{{Received {:?}}}\n\x1b[0m", event);
         }
     }
 }
 
+// Threads for waiting for messages and for jobs
+
+lazy_static! {
+    static ref HANDLE: Arc<Mutex<Option<Handle>>> = Arc::new(Mutex::new(None));
+    static ref IS_RUNNING: AtomicBool = AtomicBool::new(true);
+}
+
+struct Handle {
+    handle_imap: Option<std::thread::JoinHandle<()>>,
+    handle_mvbox: Option<std::thread::JoinHandle<()>>,
+    handle_sentbox: Option<std::thread::JoinHandle<()>>,
+    handle_smtp: Option<std::thread::JoinHandle<()>>,
+}
+
+macro_rules! while_running {
+    ($code:block) => {
+        if IS_RUNNING.load(Ordering::Relaxed) {
+            $code
+        } else {
+            break;
+        }
+    };
+}
+
+fn start_threads(c: Arc<RwLock<Context>>) {
+    if HANDLE.clone().lock().unwrap().is_some() {
+        return;
+    }
+
+    println!("Starting threads");
+    IS_RUNNING.store(true, Ordering::Relaxed);
+
+    let ctx = c.clone();
+    let handle_imap = std::thread::spawn(move || loop {
+        while_running!({
+            perform_inbox_jobs(&ctx.read().unwrap());
+            perform_inbox_fetch(&ctx.read().unwrap());
+            while_running!({
+                let context = ctx.read().unwrap();
+                perform_inbox_idle(&context);
+            });
+        });
+    });
+
+    let ctx = c.clone();
+    let handle_mvbox = std::thread::spawn(move || loop {
+        while_running!({
+            perform_mvbox_fetch(&ctx.read().unwrap());
+            while_running!({
+                perform_mvbox_idle(&ctx.read().unwrap());
+            });
+        });
+    });
+
+    let ctx = c.clone();
+    let handle_sentbox = std::thread::spawn(move || loop {
+        while_running!({
+            perform_sentbox_fetch(&ctx.read().unwrap());
+            while_running!({
+                perform_sentbox_idle(&ctx.read().unwrap());
+            });
+        });
+    });
+
+    let ctx = c;
+    let handle_smtp = std::thread::spawn(move || loop {
+        while_running!({
+            perform_smtp_jobs(&ctx.read().unwrap());
+            while_running!({
+                perform_smtp_idle(&ctx.read().unwrap());
+            });
+        });
+    });
+
+    *HANDLE.clone().lock().unwrap() = Some(Handle {
+        handle_imap: Some(handle_imap),
+        handle_mvbox: Some(handle_mvbox),
+        handle_sentbox: Some(handle_sentbox),
+        handle_smtp: Some(handle_smtp),
+    });
+}
+
+fn stop_threads(context: &Context) {
+    if let Some(ref mut handle) = *HANDLE.clone().lock().unwrap() {
+        println!("Stopping threads");
+        IS_RUNNING.store(false, Ordering::Relaxed);
+
+        interrupt_inbox_idle(context);
+        interrupt_mvbox_idle(context);
+        interrupt_sentbox_idle(context);
+        interrupt_smtp_idle(context);
+
+        handle.handle_imap.take().unwrap().join().unwrap();
+        handle.handle_mvbox.take().unwrap().join().unwrap();
+        handle.handle_sentbox.take().unwrap().join().unwrap();
+        handle.handle_smtp.take().unwrap().join().unwrap();
+    }
+}
+
 // === The main loop
 
 struct DcHelper {
@@ -145,8 +247,10 @@ const IMEX_COMMANDS: [&str; 12] = [
     "stop",
 ];
 
-const DB_COMMANDS: [&str; 9] = [
+const DB_COMMANDS: [&str; 11] = [
     "info",
+    "open",
+    "close",
     "set",
     "get",
     "oauth2",
@@ -265,81 +369,69 @@ impl Highlighter for DcHelper {
 
 impl Helper for DcHelper {}
 
-async fn start(args: Vec<String>) -> Result<(), Error> {
+fn main_0(args: Vec<String>) -> Result<(), Error> {
     if args.len() < 2 {
         println!("Error: Bad arguments, expected [db-name].");
         bail!("No db-name specified");
     }
-    let context = Context::new("CLI".into(), Path::new(&args[1]).to_path_buf()).await?;
-
-    let events = context.get_event_emitter();
-    async_std::task::spawn(async move {
-        while let Some(event) = events.recv().await {
-            receive_event(event);
-        }
-    });
+    let context = Context::new(
+        Box::new(receive_event),
+        "CLI".into(),
+        Path::new(&args[1]).to_path_buf(),
+    )?;
 
     println!("Delta Chat Core is awaiting your commands.");
 
+    let ctx = Arc::new(RwLock::new(context));
+
     let config = Config::builder()
         .history_ignore_space(true)
         .completion_type(CompletionType::List)
         .edit_mode(EditMode::Emacs)
         .output_stream(OutputStreamType::Stdout)
         .build();
-    let mut selected_chat = ChatId::default();
-    let (reader_s, reader_r) = async_std::sync::channel(100);
-    let input_loop = async_std::task::spawn_blocking(move || {
-        let h = DcHelper {
-            completer: FilenameCompleter::new(),
-            highlighter: MatchingBracketHighlighter::new(),
-            hinter: HistoryHinter {},
-        };
-        let mut rl = Editor::with_config(config);
-        rl.set_helper(Some(h));
-        rl.bind_sequence(KeyPress::Meta('N'), Cmd::HistorySearchForward);
-        rl.bind_sequence(KeyPress::Meta('P'), Cmd::HistorySearchBackward);
-        if rl.load_history(".dc-history.txt").is_err() {
-            println!("No previous history.");
-        }
+    let h = DcHelper {
+        completer: FilenameCompleter::new(),
+        highlighter: MatchingBracketHighlighter::new(),
+        hinter: HistoryHinter {},
+    };
+    let mut rl = Editor::with_config(config);
+    rl.set_helper(Some(h));
+    rl.bind_sequence(KeyPress::Meta('N'), Cmd::HistorySearchForward);
+    rl.bind_sequence(KeyPress::Meta('P'), Cmd::HistorySearchBackward);
+    if rl.load_history(".dc-history.txt").is_err() {
+        println!("No previous history.");
+    }
 
-        loop {
-            let p = "> ";
-            let readline = rl.readline(&p);
-
-            match readline {
-                Ok(line) => {
-                    // TODO: ignore "set mail_pw"
-                    rl.add_history_entry(line.as_str());
-                    async_std::task::block_on(reader_s.send(line));
-                }
-                Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => {
-                    println!("Exiting...");
-                    drop(reader_s);
-                    break;
-                }
-                Err(err) => {
-                    println!("Error: {}", err);
-                    drop(reader_s);
-                    break;
+    loop {
+        let p = "> ";
+        let readline = rl.readline(&p);
+        match readline {
+            Ok(line) => {
+                // TODO: ignore "set mail_pw"
+                rl.add_history_entry(line.as_str());
+                let ctx = ctx.clone();
+                match handle_cmd(line.trim(), ctx) {
+                    Ok(ExitResult::Continue) => {}
+                    Ok(ExitResult::Exit) => break,
+                    Err(err) => println!("Error: {}", err),
                 }
             }
-        }
-
-        rl.save_history(".dc-history.txt")?;
-        println!("history saved");
-        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),
+            Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => {
+                println!("Exiting...");
+                break;
+            }
+            Err(err) => {
+                println!("Error: {}", err);
+                break;
+            }
         }
     }
-    context.stop_io().await;
-    input_loop.await?;
+    rl.save_history(".dc-history.txt")?;
+    println!("history saved");
+    {
+        stop_threads(&ctx.read().unwrap());
+    }
 
     Ok(())
 }
@@ -350,29 +442,43 @@ enum ExitResult {
     Exit,
 }
 
-async fn handle_cmd(
-    line: &str,
-    ctx: Context,
-    selected_chat: &mut ChatId,
-) -> Result<ExitResult, Error> {
+fn handle_cmd(line: &str, ctx: Arc<RwLock<Context>>) -> Result<ExitResult, Error> {
     let mut args = line.splitn(2, ' ');
     let arg0 = args.next().unwrap_or_default();
     let arg1 = args.next().unwrap_or_default();
 
     match arg0 {
         "connect" => {
-            ctx.start_io().await;
+            start_threads(ctx);
         }
         "disconnect" => {
-            ctx.stop_io().await;
+            stop_threads(&ctx.read().unwrap());
+        }
+        "smtp-jobs" => {
+            if HANDLE.clone().lock().unwrap().is_some() {
+                println!("smtp-jobs are already running in a thread.",);
+            } else {
+                perform_smtp_jobs(&ctx.read().unwrap());
+            }
+        }
+        "imap-jobs" => {
+            if HANDLE.clone().lock().unwrap().is_some() {
+                println!("inbox-jobs are already running in a thread.");
+            } else {
+                perform_inbox_jobs(&ctx.read().unwrap());
+            }
         }
         "configure" => {
-            ctx.configure().await?;
+            start_threads(ctx.clone());
+            ctx.read().unwrap().configure();
         }
         "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;
+            if let Some(addr) = ctx.read().unwrap().get_config(config::Config::Addr) {
+                let oauth2_url = dc_get_oauth2_url(
+                    &ctx.read().unwrap(),
+                    &addr,
+                    "chat.delta:/com.b44t.messenger",
+                );
                 if oauth2_url.is_none() {
                     println!("OAuth2 not available for {}.", &addr);
                 } else {
@@ -387,10 +493,11 @@ async fn handle_cmd(
             print!("\x1b[1;1H\x1b[2J");
         }
         "getqr" | "getbadqr" => {
-            ctx.start_io().await;
-            if let Some(mut qr) =
-                dc_get_securejoin_qr(&ctx, ChatId::new(arg1.parse().unwrap_or_default())).await
-            {
+            start_threads(ctx.clone());
+            if let Some(mut qr) = dc_get_securejoin_qr(
+                &ctx.read().unwrap(),
+                ChatId::new(arg1.parse().unwrap_or_default()),
+            ) {
                 if !qr.is_empty() {
                     if arg0 == "getbadqr" && qr.len() > 40 {
                         qr.replace_range(12..22, "0000000000")
@@ -406,23 +513,23 @@ async fn handle_cmd(
             }
         }
         "joinqr" => {
-            ctx.start_io().await;
+            start_threads(ctx.clone());
             if !arg0.is_empty() {
-                dc_join_securejoin(&ctx, arg1).await;
+                dc_join_securejoin(&ctx.read().unwrap(), arg1);
             }
         }
         "exit" | "quit" => return Ok(ExitResult::Exit),
-        _ => cmdline(ctx.clone(), line, selected_chat).await?,
+        _ => dc_cmdline(&ctx.read().unwrap(), line)?,
     }
 
     Ok(ExitResult::Continue)
 }
 
-fn main() -> Result<(), Error> {
+pub 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 })?;
+    let args: Vec<String> = std::env::args().collect();
+    main_0(args)?;
 
     Ok(())
 }

examples/simple.rs

@@ -1,3 +1,7 @@
+extern crate deltachat;
+
+use std::sync::{Arc, RwLock};
+use std::{thread, time};
 use tempfile::tempdir;
 
 use deltachat::chat;
@@ -5,96 +9,103 @@ use deltachat::chatlist::*;
 use deltachat::config;
 use deltachat::contact::*;
 use deltachat::context::*;
-use deltachat::message::Message;
+use deltachat::job::{
+    perform_inbox_fetch, perform_inbox_idle, perform_inbox_jobs, perform_smtp_idle,
+    perform_smtp_jobs,
+};
 use deltachat::Event;
 
-fn cb(event: Event) {
+fn cb(_ctx: &Context, event: Event) {
+    print!("[{:?}]", event);
+
     match event {
         Event::ConfigureProgress(progress) => {
-            log::info!("progress: {}", progress);
+            println!("  progress: {}", progress);
         }
-        Event::Info(msg) => {
-            log::info!("{}", msg);
+        Event::Info(msg) | Event::Warning(msg) | Event::Error(msg) | Event::ErrorNetwork(msg) => {
+            println!("  {}", msg);
         }
-        Event::Warning(msg) => {
-            log::warn!("{}", msg);
-        }
-        Event::Error(msg) | Event::ErrorNetwork(msg) => {
-            log::error!("{}", msg);
-        }
-        event => {
-            log::info!("{:?}", event);
+        _ => {
+            println!();
         }
     }
 }
 
-/// Run with `RUST_LOG=simple=info cargo run --release --example simple --features repl -- email pw`.
-#[async_std::main]
-async fn main() {
-    pretty_env_logger::try_init_timed().ok();
-
+fn main() {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
-    log::info!("creating database {:?}", dbfile);
-    let ctx = Context::new("FakeOs".into(), dbfile.into())
-        .await
-        .expect("Failed to create context");
-    let info = ctx.get_info().await;
-    log::info!("info: {:#?}", info);
+    println!("creating database {:?}", dbfile);
+    let ctx =
+        Context::new(Box::new(cb), "FakeOs".into(), dbfile).expect("Failed to create context");
+    let running = Arc::new(RwLock::new(true));
+    let info = ctx.get_info();
+    let duration = time::Duration::from_millis(4000);
+    println!("info: {:#?}", info);
 
-    let events = ctx.get_event_emitter();
-    let events_spawn = async_std::task::spawn(async move {
-        while let Some(event) = events.recv().await {
-            cb(event);
+    let ctx = Arc::new(ctx);
+    let ctx1 = ctx.clone();
+    let r1 = running.clone();
+    let t1 = thread::spawn(move || {
+        while *r1.read().unwrap() {
+            perform_inbox_jobs(&ctx1);
+            if *r1.read().unwrap() {
+                perform_inbox_fetch(&ctx1);
+
+                if *r1.read().unwrap() {
+                    perform_inbox_idle(&ctx1);
+                }
+            }
         }
     });
 
-    log::info!("configuring");
+    let ctx1 = ctx.clone();
+    let r1 = running.clone();
+    let t2 = thread::spawn(move || {
+        while *r1.read().unwrap() {
+            perform_smtp_jobs(&ctx1);
+            if *r1.read().unwrap() {
+                perform_smtp_idle(&ctx1);
+            }
+        }
+    });
+
+    println!("configuring");
     let args = std::env::args().collect::<Vec<String>>();
-    assert_eq!(args.len(), 3, "requires email password");
-    let email = args[1].clone();
-    let pw = args[2].clone();
-    ctx.set_config(config::Config::Addr, Some(&email))
-        .await
-        .unwrap();
-    ctx.set_config(config::Config::MailPw, Some(&pw))
-        .await
+    assert_eq!(args.len(), 2, "missing password");
+    let pw = args[1].clone();
+    ctx.set_config(config::Config::Addr, Some("d@testrun.org"))
         .unwrap();
+    ctx.set_config(config::Config::MailPw, Some(&pw)).unwrap();
+    ctx.configure();
 
-    ctx.configure().await.unwrap();
+    thread::sleep(duration);
 
-    log::info!("------ RUN ------");
-    ctx.start_io().await;
-    log::info!("--- SENDING A MESSAGE ---");
+    println!("sending a message");
+    let contact_id = Contact::create(&ctx, "dignifiedquire", "dignifiedquire@gmail.com").unwrap();
+    let chat_id = chat::create_by_contact_id(&ctx, contact_id).unwrap();
+    chat::send_text_msg(&ctx, chat_id, "Hi, here is my first message!".into()).unwrap();
 
-    let contact_id = Contact::create(&ctx, "dignifiedquire", "dignifiedquire@gmail.com")
-        .await
-        .unwrap();
-    let chat_id = chat::create_by_contact_id(&ctx, contact_id).await.unwrap();
-
-    for i in 0..1 {
-        log::info!("sending message {}", i);
-        chat::send_text_msg(&ctx, chat_id, format!("Hi, here is my {}nth message!", i))
-            .await
-            .unwrap();
-    }
-
-    // wait for the message to be sent out
-    async_std::task::sleep(std::time::Duration::from_secs(1)).await;
-
-    log::info!("fetching chats..");
-    let chats = Chatlist::try_load(&ctx, 0, None, None).await.unwrap();
+    println!("fetching chats..");
+    let chats = Chatlist::try_load(&ctx, 0, None, None).unwrap();
 
     for i in 0..chats.len() {
-        let msg = Message::load_from_db(&ctx, chats.get_msg_id(i).unwrap())
-            .await
-            .unwrap();
-        log::info!("[{}] msg: {:?}", i, msg);
+        let summary = chats.get_summary(&ctx, 0, None);
+        let text1 = summary.get_text1();
+        let text2 = summary.get_text2();
+        println!("chat: {} - {:?} - {:?}", i, text1, text2,);
     }
 
-    log::info!("stopping");
-    ctx.stop_io().await;
-    log::info!("closing");
-    drop(ctx);
-    events_spawn.await;
+    thread::sleep(duration);
+
+    println!("stopping threads");
+
+    *running.write().unwrap() = false;
+    deltachat::job::interrupt_inbox_idle(&ctx);
+    deltachat::job::interrupt_smtp_idle(&ctx);
+
+    println!("joining");
+    t1.join().unwrap();
+    t2.join().unwrap();
+
+    println!("closing");
 }

python/README.rst

@@ -113,10 +113,10 @@ You may look at `examples <https://py.delta.chat/examples.html>`_.
 .. _`deltachat-core`: https://github.com/deltachat/deltachat-core-rust
 
 
-Building manylinux based wheels
-====================================
+Building manylinux1 based wheels
+================================
 
-Building portable manylinux wheels which come with libdeltachat.so
+Building portable manylinux1 wheels which come with libdeltachat.so
 can be done with docker-tooling.
 
 using docker pull / premade images

python/examples/echo_and_quit.py

@@ -14,11 +14,8 @@ class EchoPlugin:
             # unconditionally accept the chat
             message.accept_sender_contact()
             addr = message.get_sender_contact().addr
-            if message.is_system_message():
-                message.chat.send_text("echoing system message from {}:\n{}".format(addr, message))
-            else:
-                text = message.text
-                message.chat.send_text("echoing from {}:\n{}".format(addr, text))
+            text = message.text
+            message.chat.send_text("echoing from {}:\n{}".format(addr, text))
 
     @account_hookimpl
     def ac_message_delivered(self, message):

python/examples/test_examples.py

@@ -3,7 +3,7 @@ import pytest
 import py
 import echo_and_quit
 import group_tracking
-from deltachat.events import FFIEventLogger
+from deltachat.eventlogger import FFIEventLogger
 
 
 @pytest.fixture(scope='session')
@@ -17,23 +17,16 @@ def datadir():
         pytest.skip('test-data directory not found')
 
 
-def test_echo_quit_plugin(acfactory, lp):
-    lp.sec("creating one echo_and_quit bot")
+def test_echo_quit_plugin(acfactory):
     botproc = acfactory.run_bot_process(echo_and_quit)
 
-    lp.sec("creating a temp account to contact the bot")
     ac1 = acfactory.get_one_online_account()
-
-    lp.sec("sending a message to the bot")
     bot_contact = ac1.create_contact(botproc.addr)
     ch1 = ac1.create_chat_by_contact(bot_contact)
     ch1.send_text("hello")
-
-    lp.sec("waiting for the bot-reply to arrive")
     reply = ac1._evtracker.wait_next_incoming_message()
     assert "hello" in reply.text
     assert reply.chat == ch1
-    lp.sec("send quit sequence")
     ch1.send_text("/quit")
     botproc.wait()
 

python/fail_test.py

@@ -1,7 +0,0 @@
-from __future__ import print_function
-from deltachat import capi
-from deltachat.capi import ffi, lib
-
-if __name__ == "__main__":
-    ctx = capi.lib.dc_context_new(ffi.NULL, ffi.NULL)
-    lib.dc_stop_io(ctx)

python/install_python_bindings.py

@@ -19,7 +19,6 @@ if __name__ == "__main__":
     cmd = ["cargo", "build", "-p", "deltachat_ffi"]
     if target == 'release':
         cmd.append("--release")
-    print("running:", " ".join(cmd))
     subprocess.check_call(cmd)
     subprocess.check_call("rm -rf build/ src/deltachat/*.so" , shell=True)
 

python/src/deltachat/__init__.py

@@ -1,13 +1,13 @@
 import sys
 
-from . import capi, const, hookspec # noqa
-from .capi import ffi  # noqa
+from . import capi, const, hookspec
+from .capi import ffi
 from .account import Account  # noqa
 from .message import Message  # noqa
 from .contact import Contact  # noqa
 from .chat import Chat        # noqa
 from .hookspec import account_hookimpl, global_hookimpl  # noqa
-from . import events
+from . import eventlogger
 
 from pkg_resources import get_distribution, DistributionNotFound
 try:
@@ -17,6 +17,64 @@ except DistributionNotFound:
     __version__ = "0.0.0.dev0-unknown"
 
 
+_DC_CALLBACK_MAP = {}
+
+
+@capi.ffi.def_extern()
+def py_dc_callback(ctx, evt, data1, data2):
+    """The global event handler.
+
+    CFFI only allows us to set one global event handler, so this one
+    looks up the correct event handler for the given context.
+    """
+    try:
+        callback = _DC_CALLBACK_MAP.get(ctx, lambda *a: 0)
+    except AttributeError:
+        # we are in a deep in GC-free/interpreter shutdown land
+        # nothing much better to do here than:
+        return 0
+
+    # the following code relates to the deltachat/_build.py's helper
+    # function which provides us signature info of an event call
+    evt_name = get_dc_event_name(evt)
+    event_sig_types = capi.lib.dc_get_event_signature_types(evt)
+    if data1 and event_sig_types & 1:
+        data1 = ffi.string(ffi.cast('char*', data1)).decode("utf8")
+    if data2 and event_sig_types & 2:
+        data2 = ffi.string(ffi.cast('char*', data2)).decode("utf8")
+        try:
+            if isinstance(data2, bytes):
+                data2 = data2.decode("utf8")
+        except UnicodeDecodeError:
+            # XXX ignoring the decode error is not quite correct but for now
+            # i don't want to hunt down encoding problems in the c lib
+            pass
+    try:
+        ret = callback(ctx, evt_name, data1, data2)
+        if ret is None:
+            ret = 0
+        assert isinstance(ret, int), repr(ret)
+        if event_sig_types & 4:
+            return ffi.cast('uintptr_t', ret)
+        elif event_sig_types & 8:
+            return ffi.cast('int', ret)
+    except:  # noqa
+        raise
+        ret = 0
+    return ret
+
+
+def set_context_callback(dc_context, func):
+    _DC_CALLBACK_MAP[dc_context] = func
+
+
+def clear_context_callback(dc_context):
+    try:
+        _DC_CALLBACK_MAP.pop(dc_context, None)
+    except AttributeError:
+        pass
+
+
 def get_dc_event_name(integer, _DC_EVENTNAME_MAP={}):
     if not _DC_EVENTNAME_MAP:
         for name, val in vars(const).items():
@@ -39,7 +97,7 @@ def unregister_global_plugin(plugin):
     gm.unregister(plugin)
 
 
-register_global_plugin(events)
+register_global_plugin(eventlogger)
 
 
 def run_cmdline(argv=None, account_plugins=None):
@@ -60,13 +118,9 @@ def run_cmdline(argv=None, account_plugins=None):
     ac = Account(args.db)
 
     if args.show_ffi:
-        log = events.FFIEventLogger(ac, "bot")
+        log = eventlogger.FFIEventLogger(ac, "bot")
         ac.add_account_plugin(log)
 
-    for plugin in account_plugins or []:
-        print("adding plugin", plugin)
-        ac.add_account_plugin(plugin)
-
     if not ac.is_configured():
         assert args.email and args.password, (
             "you must specify --email and --password once to configure this database/account"
@@ -76,11 +130,12 @@ def run_cmdline(argv=None, account_plugins=None):
         ac.set_config("mvbox_move", "0")
         ac.set_config("mvbox_watch", "0")
         ac.set_config("sentbox_watch", "0")
-        ac.configure()
-        ac.wait_configure_finish()
+
+    for plugin in account_plugins or []:
+        ac.add_account_plugin(plugin)
 
     # start IO threads and configure if neccessary
-    ac.start_io()
+    ac.start()
 
     print("{}: waiting for message".format(ac.get_config("addr")))
 

python/src/deltachat/_build.py

@@ -45,9 +45,22 @@ def ffibuilder():
         'deltachat.capi',
         """
             #include <deltachat.h>
-            int dc_event_has_string_data(int e)
+            const char * dupstring_helper(const char* string)
             {
-                return DC_EVENT_DATA2_IS_STRING(e);
+                return strdup(string);
+            }
+            int dc_get_event_signature_types(int e)
+            {
+                int result = 0;
+                if (DC_EVENT_DATA1_IS_STRING(e))
+                    result |= 1;
+                if (DC_EVENT_DATA2_IS_STRING(e))
+                    result |= 2;
+                if (DC_EVENT_RETURNS_STRING(e))
+                    result |= 4;
+                if (DC_EVENT_RETURNS_INT(e))
+                    result |= 8;
+                return result;
             }
         """,
         include_dirs=incs,
@@ -58,7 +71,8 @@ def ffibuilder():
     builder.cdef("""
         typedef int... time_t;
         void free(void *ptr);
-        extern int dc_event_has_string_data(int);
+        extern const char * dupstring_helper(const char* string);
+        extern int dc_get_event_signature_types(int);
     """)
     distutils.log.set_verbosity(distutils.log.INFO)
     cc = distutils.ccompiler.new_compiler(force=True)
@@ -78,6 +92,13 @@ def ffibuilder():
     finally:
         shutil.rmtree(tmpdir)
 
+    builder.cdef("""
+        extern "Python" uintptr_t py_dc_callback(
+            dc_context_t* context,
+            int event,
+            uintptr_t data1,
+            uintptr_t data2);
+    """)
     return builder
 
 

python/src/deltachat/account.py

@@ -1,20 +1,22 @@
 """ Account class implementation. """
 
 from __future__ import print_function
+import atexit
 from contextlib import contextmanager
 from email.utils import parseaddr
+import queue
 from threading import Event
 import os
 from array import array
+import deltachat
 from . import const
 from .capi import ffi, lib
 from .cutil import as_dc_charpointer, from_dc_charpointer, iter_array, DCLot
 from .chat import Chat
-from .message import Message
+from .message import Message, map_system_message
 from .contact import Contact
-from .tracker import ImexTracker, ConfigureTracker
-from . import hookspec
-from .events import EventThread
+from .tracker import ImexTracker
+from . import hookspec, iothreads
 
 
 class MissingCredentials(ValueError):
@@ -38,24 +40,28 @@ class Account(object):
         # initialize per-account plugin system
         self._pm = hookspec.PerAccount._make_plugin_manager()
         self._logging = logging
-
         self.add_account_plugin(self)
 
+        self._dc_context = ffi.gc(
+            lib.dc_context_new(lib.py_dc_callback, ffi.NULL, as_dc_charpointer(os_name)),
+            _destroy_dc_context,
+        )
+
+        hook = hookspec.Global._get_plugin_manager().hook
+
+        self._threads = iothreads.IOThreads(self)
+        self._hook_event_queue = queue.Queue()
+        self._in_use_iter_events = False
+        self._shutdown_event = Event()
+
+        # open database
         self.db_path = db_path
         if hasattr(db_path, "encode"):
             db_path = db_path.encode("utf8")
-
-        self._dc_context = ffi.gc(
-            lib.dc_context_new(as_dc_charpointer(os_name), db_path, ffi.NULL),
-            lib.dc_context_unref,
-        )
-        if self._dc_context == ffi.NULL:
-            raise ValueError("Could not dc_context_new: {} {}".format(os_name, db_path))
-
-        self._shutdown_event = Event()
-        self._event_thread = EventThread(self)
+        if not lib.dc_open(self._dc_context, db_path, ffi.NULL):
+            raise ValueError("Could not dc_open: {}".format(db_path))
         self._configkeys = self.get_config("sys.config_keys").split()
-        hook = hookspec.Global._get_plugin_manager().hook
+        atexit.register(self.shutdown)
         hook.dc_account_init(account=self)
 
     def disable_logging(self):
@@ -66,10 +72,16 @@ class Account(object):
         """ re-enable logging. """
         self._logging = True
 
+    @hookspec.account_hookimpl
+    def ac_process_ffi_event(self, ffi_event):
+        for name, kwargs in self._map_ffi_event(ffi_event):
+            ev = HookEvent(self, name=name, kwargs=kwargs)
+            self._hook_event_queue.put(ev)
+
     # def __del__(self):
     #    self.shutdown()
 
-    def log(self, msg):
+    def ac_log_line(self, msg):
         if self._logging:
             self._pm.hook.ac_log_line(message=msg)
 
@@ -160,7 +172,7 @@ class Account(object):
 
         :returns: True if account is configured.
         """
-        return True if lib.dc_is_configured(self._dc_context) else False
+        return bool(lib.dc_is_configured(self._dc_context))
 
     def set_avatar(self, img_path):
         """Set self avatar.
@@ -238,7 +250,7 @@ class Account(object):
         :returns: True if deletion succeeded (contact was deleted)
         """
         contact_id = contact.id
-        assert contact.account == self
+        assert contact._dc_context == self._dc_context
         assert contact_id > const.DC_CHAT_ID_LAST_SPECIAL
         return bool(lib.dc_delete_contact(self._dc_context, contact_id))
 
@@ -286,7 +298,7 @@ class Account(object):
         :returns: a :class:`deltachat.chat.Chat` object.
         """
         if hasattr(contact, "id"):
-            if contact.account != self:
+            if contact._dc_context != self._dc_context:
                 raise ValueError("Contact belongs to a different Account")
             contact_id = contact.id
         else:
@@ -306,7 +318,7 @@ class Account(object):
         :returns: a :class:`deltachat.chat.Chat` object.
         """
         if hasattr(message, "id"):
-            if message.account != self:
+            if self._dc_context != message._dc_context:
                 raise ValueError("Message belongs to a different Account")
             msg_id = message.id
         else:
@@ -426,6 +438,8 @@ class Account(object):
     def _export(self, path, imex_cmd):
         with self.temp_plugin(ImexTracker()) as imex_tracker:
             lib.dc_imex(self._dc_context, imex_cmd, as_dc_charpointer(path), ffi.NULL)
+            if not self._threads.is_started():
+                lib.dc_perform_imap_jobs(self._dc_context)
             return imex_tracker.wait_finish()
 
     def import_self_keys(self, path):
@@ -448,6 +462,8 @@ class Account(object):
     def _import(self, path, imex_cmd):
         with self.temp_plugin(ImexTracker()) as imex_tracker:
             lib.dc_imex(self._dc_context, imex_cmd, as_dc_charpointer(path), ffi.NULL)
+            if not self._threads.is_started():
+                lib.dc_perform_imap_jobs(self._dc_context)
             imex_tracker.wait_finish()
 
     def initiate_key_transfer(self):
@@ -456,8 +472,8 @@ class Account(object):
         If sending out was unsuccessful, a RuntimeError is raised.
         """
         self.check_is_configured()
-        if not self.is_started():
-            raise RuntimeError("IO not running, can not send out")
+        if not self._threads.is_started():
+            raise RuntimeError("threads not running, can not send out")
         res = lib.dc_initiate_key_transfer(self._dc_context)
         if res == ffi.NULL:
             raise RuntimeError("could not send out autocrypt setup message")
@@ -539,10 +555,6 @@ class Account(object):
         self._pm.check_pending()
         return plugin
 
-    def remove_account_plugin(self, plugin, name=None):
-        """ remove an account plugin. """
-        self._pm.unregister(plugin, name=name)
-
     @contextmanager
     def temp_plugin(self, plugin):
         """ run a with-block with the given plugin temporarily registered. """
@@ -554,82 +566,110 @@ class Account(object):
         """ Stop ongoing securejoin, configuration or other core jobs. """
         lib.dc_stop_ongoing_process(self._dc_context)
 
-    def start_io(self):
-        """ start this account's IO scheduling (Rust-core async scheduler)
+    def start(self, callback_thread=True):
+        """ start this account (activate imap/smtp threads etc.)
+        and return immediately.
 
-        If this account is not configured an Exception is raised.
-        You need to call account.configure() and account.wait_configure_finish()
-        before.
+        If this account is not configured, an internal configuration
+        job will be scheduled if config values are sufficiently specified.
 
-        You may call `stop_scheduler`, `wait_shutdown` or `shutdown` after the
-        account is started.
+        You may call `wait_shutdown` or `shutdown` after the
+        account is in started mode.
 
         :raises MissingCredentials: if `addr` and `mail_pw` values are not set.
-        :raises ConfigureFailed: if the account could not be configured.
 
-        :returns: None (account is configured and with io-scheduling running)
+        :returns: None
         """
         if not self.is_configured():
-            raise ValueError("account not configured, cannot start io")
-        lib.dc_start_io(self._dc_context)
-
-    def configure(self):
-        assert not self.is_configured()
-        assert not hasattr(self, "_configtracker")
-        if not self.get_config("addr") or not self.get_config("mail_pw"):
-            raise MissingCredentials("addr or mail_pwd not set in config")
-        if hasattr(self, "_configtracker"):
-            self.remove_account_plugin(self._configtracker)
-        self._configtracker = ConfigureTracker()
-        self.add_account_plugin(self._configtracker)
-        lib.dc_configure(self._dc_context)
-
-    def wait_configure_finish(self):
-        try:
-            self._configtracker.wait_finish()
-        finally:
-            self.remove_account_plugin(self._configtracker)
-            del self._configtracker
-
-    def is_started(self):
-        return self._event_thread.is_alive() and bool(lib.dc_is_io_running(self._dc_context))
+            if not self.get_config("addr") or not self.get_config("mail_pw"):
+                raise MissingCredentials("addr or mail_pwd not set in config")
+            lib.dc_configure(self._dc_context)
+        self._threads.start(callback_thread=callback_thread)
 
     def wait_shutdown(self):
         """ wait until shutdown of this account has completed. """
         self._shutdown_event.wait()
 
-    def stop_io(self):
-        """ stop core IO scheduler if it is running. """
-        self.log("stop_ongoing")
-        self.stop_ongoing()
-
-        if bool(lib.dc_is_io_running(self._dc_context)):
-            self.log("dc_stop_io (stop core IO scheduler)")
-            lib.dc_stop_io(self._dc_context)
-        else:
-            self.log("stop_scheduler called on non-running context")
-
-    def shutdown(self):
-        """ shutdown and destroy account (stop callback thread, close and remove
-        underlying dc_context)."""
-        if self._dc_context is None:
+    def shutdown(self, wait=True):
+        """ shutdown account, stop threads and close and remove
+        underlying dc_context and callbacks. """
+        dc_context = self._dc_context
+        if dc_context is None:
             return
 
-        self.stop_io()
-
-        self.log("remove dc_context references")
-        # the dc_context_unref triggers get_next_event to return ffi.NULL
-        # which in turns makes the event thread finish execution
+        if self._threads.is_started():
+            self.stop_ongoing()
+            self._threads.stop(wait=False)
+        lib.dc_close(dc_context)
+        self._hook_event_queue.put(None)
+        self._threads.stop(wait=wait)  # to wait for threads
         self._dc_context = None
-
-        self.log("wait for event thread to finish")
-        self._event_thread.wait()
-
+        atexit.unregister(self.shutdown)
         self._shutdown_event.set()
-
         hook = hookspec.Global._get_plugin_manager().hook
-        hook.dc_account_after_shutdown(account=self)
-        self.log("shutdown finished")
+        hook.dc_account_after_shutdown(account=self, dc_context=dc_context)
+
+    def _handle_current_events(self):
+        """ handle all currently queued events and then return. """
+        while 1:
+            try:
+                event = self._hook_event_queue.get(block=False)
+            except queue.Empty:
+                break
+            else:
+                event.call_hook()
+
+    def iter_events(self, timeout=None):
+        """ yield hook events until shutdown.
+
+        It is not allowed to call iter_events() from multiple threads.
+        """
+        if self._in_use_iter_events:
+            raise RuntimeError("can only call iter_events() from one thread")
+        self._in_use_iter_events = True
+        while 1:
+            event = self._hook_event_queue.get(timeout=timeout)
+            if event is None:
+                break
+            yield event
+
+    def _map_ffi_event(self, ffi_event):
+        name = ffi_event.name
+        if name == "DC_EVENT_CONFIGURE_PROGRESS":
+            data1 = ffi_event.data1
+            if data1 == 0 or data1 == 1000:
+                success = data1 == 1000
+                yield "ac_configure_completed", dict(success=success)
+        elif name == "DC_EVENT_INCOMING_MSG":
+            msg = self.get_message_by_id(ffi_event.data2)
+            yield map_system_message(msg) or ("ac_incoming_message", dict(message=msg))
+        elif name == "DC_EVENT_MSGS_CHANGED":
+            if ffi_event.data2 != 0:
+                msg = self.get_message_by_id(ffi_event.data2)
+                if msg.is_outgoing():
+                    res = map_system_message(msg)
+                    if res and res[0].startswith("ac_member"):
+                        yield res
+                    yield "ac_outgoing_message", dict(message=msg)
+                elif msg.is_in_fresh():
+                    yield map_system_message(msg) or ("ac_incoming_message", dict(message=msg))
+        elif name == "DC_EVENT_MSG_DELIVERED":
+            msg = self.get_message_by_id(ffi_event.data2)
+            yield "ac_message_delivered", dict(message=msg)
+        elif name == "DC_EVENT_CHAT_MODIFIED":
+            chat = self.get_chat_by_id(ffi_event.data1)
+            yield "ac_chat_modified", dict(chat=chat)
+
+
+def _destroy_dc_context(dc_context, dc_context_unref=lib.dc_context_unref):
+    # destructor for dc_context
+    dc_context_unref(dc_context)
+    try:
+        deltachat.clear_context_callback(dc_context)
+    except (TypeError, AttributeError):
+        # we are deep into Python Interpreter shutdown,
+        # so no need to clear the callback context mapping.
+        pass
 
 
 class ScannedQRCode:
@@ -645,3 +685,17 @@ class ScannedQRCode:
     @property
     def contact_id(self):
         return self._dc_lot.id()
+
+
+class HookEvent:
+    def __init__(self, account, name, kwargs):
+        assert hasattr(account._pm.hook, name), name
+        self.account = account
+        self.name = name
+        self.kwargs = kwargs
+
+    def call_hook(self):
+        hook = getattr(self.account._pm.hook, self.name, None)
+        if hook is None:
+            raise ValueError("event_name {} unknown".format(self.name))
+        return hook(**self.kwargs)

python/src/deltachat/chat.py

@@ -19,11 +19,12 @@ class Chat(object):
 
     def __init__(self, account, id):
         self.account = account
+        self._dc_context = account._dc_context
         self.id = id
 
     def __eq__(self, other):
         return self.id == getattr(other, "id", None) and \
-               self.account._dc_context == other.account._dc_context
+               self._dc_context == getattr(other, "_dc_context", None)
 
     def __ne__(self, other):
         return not (self == other)
@@ -34,7 +35,7 @@ class Chat(object):
     @property
     def _dc_chat(self):
         return ffi.gc(
-            lib.dc_get_chat(self.account._dc_context, self.id),
+            lib.dc_get_chat(self._dc_context, self.id),
             lib.dc_chat_unref
         )
 
@@ -46,7 +47,7 @@ class Chat(object):
         - does not delete messages on server
         - the chat or contact is not blocked, new message will arrive
         """
-        lib.dc_delete_chat(self.account._dc_context, self.id)
+        lib.dc_delete_chat(self._dc_context, self.id)
 
     # ------  chat status/metadata API ------------------------------
 
@@ -104,7 +105,7 @@ class Chat(object):
         :returns: None
         """
         name = as_dc_charpointer(name)
-        return lib.dc_set_chat_name(self.account._dc_context, self.id, name)
+        return lib.dc_set_chat_name(self._dc_context, self.id, name)
 
     def mute(self, duration=None):
         """ mutes the chat
@@ -116,7 +117,7 @@ class Chat(object):
             mute_duration = -1
         else:
             mute_duration = duration
-        ret = lib.dc_set_chat_mute_duration(self.account._dc_context, self.id, mute_duration)
+        ret = lib.dc_set_chat_mute_duration(self._dc_context, self.id, mute_duration)
         if not bool(ret):
             raise ValueError("Call to dc_set_chat_mute_duration failed")
 
@@ -125,7 +126,7 @@ class Chat(object):
 
         :returns: None
         """
-        ret = lib.dc_set_chat_mute_duration(self.account._dc_context, self.id, 0)
+        ret = lib.dc_set_chat_mute_duration(self._dc_context, self.id, 0)
         if not bool(ret):
             raise ValueError("Failed to unmute chat")
 
@@ -151,7 +152,7 @@ class Chat(object):
         in a second channel (typically used by mobiles with QRcode-show + scan UX)
         where account.join_with_qrcode(qr) needs to be called.
         """
-        res = lib.dc_get_securejoin_qr(self.account._dc_context, self.id)
+        res = lib.dc_get_securejoin_qr(self._dc_context, self.id)
         return from_dc_charpointer(res)
 
     # ------  chat messaging API ------------------------------
@@ -173,7 +174,7 @@ class Chat(object):
             assert msg.id != 0
             # get a fresh copy of dc_msg, the core needs it
             msg = Message.from_db(self.account, msg.id)
-        sent_id = lib.dc_send_msg(self.account._dc_context, self.id, msg._dc_msg)
+        sent_id = lib.dc_send_msg(self._dc_context, self.id, msg._dc_msg)
         if sent_id == 0:
             raise ValueError("message could not be sent")
         # modify message in place to avoid bad state for the caller
@@ -188,7 +189,7 @@ class Chat(object):
         :returns: the resulting :class:`deltachat.message.Message` instance
         """
         msg = as_dc_charpointer(text)
-        msg_id = lib.dc_send_text_msg(self.account._dc_context, self.id, msg)
+        msg_id = lib.dc_send_text_msg(self._dc_context, self.id, msg)
         if msg_id == 0:
             raise ValueError("message could not be send, does chat exist?")
         return Message.from_db(self.account, msg_id)
@@ -203,7 +204,7 @@ class Chat(object):
         """
         msg = Message.new_empty(self.account, view_type="file")
         msg.set_file(path, mime_type)
-        sent_id = lib.dc_send_msg(self.account._dc_context, self.id, msg._dc_msg)
+        sent_id = lib.dc_send_msg(self._dc_context, self.id, msg._dc_msg)
         if sent_id == 0:
             raise ValueError("message could not be sent")
         return Message.from_db(self.account, sent_id)
@@ -218,7 +219,7 @@ class Chat(object):
         mime_type = mimetypes.guess_type(path)[0]
         msg = Message.new_empty(self.account, view_type="image")
         msg.set_file(path, mime_type)
-        sent_id = lib.dc_send_msg(self.account._dc_context, self.id, msg._dc_msg)
+        sent_id = lib.dc_send_msg(self._dc_context, self.id, msg._dc_msg)
         if sent_id == 0:
             raise ValueError("message could not be sent")
         return Message.from_db(self.account, sent_id)
@@ -229,7 +230,7 @@ class Chat(object):
         :param msg: the message to be prepared.
         :returns: :class:`deltachat.message.Message` instance.
         """
-        msg_id = lib.dc_prepare_msg(self.account._dc_context, self.id, msg._dc_msg)
+        msg_id = lib.dc_prepare_msg(self._dc_context, self.id, msg._dc_msg)
         if msg_id == 0:
             raise ValueError("message could not be prepared")
         # invalidate passed in message which is not safe to use anymore
@@ -265,7 +266,7 @@ class Chat(object):
         msg = Message.from_db(self.account, message.id)
 
         # pass 0 as chat-id because core-docs say it's ok when out-preparing
-        sent_id = lib.dc_send_msg(self.account._dc_context, 0, msg._dc_msg)
+        sent_id = lib.dc_send_msg(self._dc_context, 0, msg._dc_msg)
         if sent_id == 0:
             raise ValueError("message could not be sent")
         assert sent_id == msg.id
@@ -279,9 +280,9 @@ class Chat(object):
         :returns: None
         """
         if message is None:
-            lib.dc_set_draft(self.account._dc_context, self.id, ffi.NULL)
+            lib.dc_set_draft(self._dc_context, self.id, ffi.NULL)
         else:
-            lib.dc_set_draft(self.account._dc_context, self.id, message._dc_msg)
+            lib.dc_set_draft(self._dc_context, self.id, message._dc_msg)
 
     def get_draft(self):
         """ get draft message for this chat.
@@ -289,7 +290,7 @@ class Chat(object):
         :param message: a :class:`Message` instance
         :returns: Message object or None (if no draft available)
         """
-        x = lib.dc_get_draft(self.account._dc_context, self.id)
+        x = lib.dc_get_draft(self._dc_context, self.id)
         if x == ffi.NULL:
             return None
         dc_msg = ffi.gc(x, lib.dc_msg_unref)
@@ -301,7 +302,7 @@ class Chat(object):
         :returns: list of :class:`deltachat.message.Message` objects for this chat.
         """
         dc_array = ffi.gc(
-            lib.dc_get_chat_msgs(self.account._dc_context, self.id, 0, 0),
+            lib.dc_get_chat_msgs(self._dc_context, self.id, 0, 0),
             lib.dc_array_unref
         )
         return list(iter_array(dc_array, lambda x: Message.from_db(self.account, x)))
@@ -311,18 +312,18 @@ class Chat(object):
 
         :returns: number of fresh messages
         """
-        return lib.dc_get_fresh_msg_cnt(self.account._dc_context, self.id)
+        return lib.dc_get_fresh_msg_cnt(self._dc_context, self.id)
 
     def mark_noticed(self):
         """ mark all messages in this chat as noticed.
 
         Noticed messages are no longer fresh.
         """
-        return lib.dc_marknoticed_chat(self.account._dc_context, self.id)
+        return lib.dc_marknoticed_chat(self._dc_context, self.id)
 
     def get_summary(self):
         """ return dictionary with summary information. """
-        dc_res = lib.dc_chat_get_info_json(self.account._dc_context, self.id)
+        dc_res = lib.dc_chat_get_info_json(self._dc_context, self.id)
         s = from_dc_charpointer(dc_res)
         return json.loads(s)
 
@@ -335,7 +336,7 @@ class Chat(object):
         :raises ValueError: if contact could not be added
         :returns: None
         """
-        ret = lib.dc_add_contact_to_chat(self.account._dc_context, self.id, contact.id)
+        ret = lib.dc_add_contact_to_chat(self._dc_context, self.id, contact.id)
         if ret != 1:
             raise ValueError("could not add contact {!r} to chat".format(contact))
 
@@ -346,7 +347,7 @@ class Chat(object):
         :raises ValueError: if contact could not be removed
         :returns: None
         """
-        ret = lib.dc_remove_contact_from_chat(self.account._dc_context, self.id, contact.id)
+        ret = lib.dc_remove_contact_from_chat(self._dc_context, self.id, contact.id)
         if ret != 1:
             raise ValueError("could not remove contact {!r} from chat".format(contact))
 
@@ -358,7 +359,7 @@ class Chat(object):
         """
         from .contact import Contact
         dc_array = ffi.gc(
-            lib.dc_get_chat_contacts(self.account._dc_context, self.id),
+            lib.dc_get_chat_contacts(self._dc_context, self.id),
             lib.dc_array_unref
         )
         return list(iter_array(
@@ -377,7 +378,7 @@ class Chat(object):
         """
         assert os.path.exists(img_path), img_path
         p = as_dc_charpointer(img_path)
-        res = lib.dc_set_chat_profile_image(self.account._dc_context, self.id, p)
+        res = lib.dc_set_chat_profile_image(self._dc_context, self.id, p)
         if res != 1:
             raise ValueError("Setting Profile Image {!r} failed".format(p))
 
@@ -390,7 +391,7 @@ class Chat(object):
         :raises ValueError: if profile image could not be reset
         :returns: None
         """
-        res = lib.dc_set_chat_profile_image(self.account._dc_context, self.id, ffi.NULL)
+        res = lib.dc_set_chat_profile_image(self._dc_context, self.id, ffi.NULL)
         if res != 1:
             raise ValueError("Removing Profile Image failed")
 
@@ -420,7 +421,7 @@ class Chat(object):
         """return True if this chat has location-sending enabled currently.
         :returns: True if location sending is enabled.
         """
-        return lib.dc_is_sending_locations_to_chat(self.account._dc_context, self.id)
+        return lib.dc_is_sending_locations_to_chat(self._dc_context, self.id)
 
     def is_archived(self):
         """return True if this chat is archived.
@@ -433,7 +434,7 @@ class Chat(object):
 
         all subsequent messages will carry a location with them.
         """
-        lib.dc_send_locations_to_chat(self.account._dc_context, self.id, seconds)
+        lib.dc_send_locations_to_chat(self._dc_context, self.id, seconds)
 
     def get_locations(self, contact=None, timestamp_from=None, timestamp_to=None):
         """return list of locations for the given contact in the given timespan.
@@ -457,7 +458,7 @@ class Chat(object):
         else:
             contact_id = contact.id
 
-        dc_array = lib.dc_get_locations(self.account._dc_context, self.id, contact_id, time_from, time_to)
+        dc_array = lib.dc_get_locations(self._dc_context, self.id, contact_id, time_from, time_to)
         return [
             Location(
                 latitude=lib.dc_array_get_latitude(dc_array, i),

python/src/deltachat/contact.py

@@ -12,21 +12,22 @@ class Contact(object):
     """
     def __init__(self, account, id):
         self.account = account
+        self._dc_context = account._dc_context
         self.id = id
 
     def __eq__(self, other):
-        return self.account._dc_context == other.account._dc_context and self.id == other.id
+        return self._dc_context == other._dc_context and self.id == other.id
 
     def __ne__(self, other):
         return not (self == other)
 
     def __repr__(self):
-        return "<Contact id={} addr={} dc_context={}>".format(self.id, self.addr, self.account._dc_context)
+        return "<Contact id={} addr={} dc_context={}>".format(self.id, self.addr, self._dc_context)
 
     @property
     def _dc_contact(self):
         return ffi.gc(
-            lib.dc_get_contact(self.account._dc_context, self.id),
+            lib.dc_get_contact(self._dc_context, self.id),
             lib.dc_contact_unref
         )
 

python/src/deltachat/eventlogger.py

@@ -0,0 +1,137 @@
+import deltachat
+import threading
+import time
+import re
+from queue import Queue, Empty
+from .hookspec import account_hookimpl, global_hookimpl
+
+
+@global_hookimpl
+def dc_account_init(account):
+    # send all FFI events for this account to a plugin hook
+    def _ll_event(ctx, evt_name, data1, data2):
+        assert ctx == account._dc_context
+        ffi_event = FFIEvent(name=evt_name, data1=data1, data2=data2)
+        account._pm.hook.ac_process_ffi_event(
+            account=account, ffi_event=ffi_event
+        )
+    deltachat.set_context_callback(account._dc_context, _ll_event)
+
+
+@global_hookimpl
+def dc_account_after_shutdown(dc_context):
+    deltachat.clear_context_callback(dc_context)
+
+
+class FFIEvent:
+    def __init__(self, name, data1, data2):
+        self.name = name
+        self.data1 = data1
+        self.data2 = data2
+
+    def __str__(self):
+        return "{name} data1={data1} data2={data2}".format(**self.__dict__)
+
+
+class FFIEventLogger:
+    """ If you register an instance of this logger with an Account
+    you'll get all ffi-events printed.
+    """
+    # to prevent garbled logging
+    _loglock = threading.RLock()
+
+    def __init__(self, account, logid):
+        """
+        :param logid: an optional logging prefix that should be used with
+                      the default internal logging.
+        """
+        self.account = account
+        self.logid = logid
+        self.init_time = time.time()
+
+    @account_hookimpl
+    def ac_process_ffi_event(self, ffi_event):
+        self._log_event(ffi_event)
+
+    def _log_event(self, ffi_event):
+        # don't show events that are anyway empty impls now
+        if ffi_event.name == "DC_EVENT_GET_STRING":
+            return
+        self.account.ac_log_line(str(ffi_event))
+
+    @account_hookimpl
+    def ac_log_line(self, message):
+        t = threading.currentThread()
+        tname = getattr(t, "name", t)
+        if tname == "MainThread":
+            tname = "MAIN"
+        elapsed = time.time() - self.init_time
+        locname = tname
+        if self.logid:
+            locname += "-" + self.logid
+        s = "{:2.2f} [{}] {}".format(elapsed, locname, message)
+        with self._loglock:
+            print(s, flush=True)
+
+
+class FFIEventTracker:
+    def __init__(self, account, timeout=None):
+        self.account = account
+        self._timeout = timeout
+        self._event_queue = Queue()
+
+    @account_hookimpl
+    def ac_process_ffi_event(self, ffi_event):
+        self._event_queue.put(ffi_event)
+
+    def set_timeout(self, timeout):
+        self._timeout = timeout
+
+    def consume_events(self, check_error=True):
+        while not self._event_queue.empty():
+            self.get(check_error=check_error)
+
+    def get(self, timeout=None, check_error=True):
+        timeout = timeout if timeout is not None else self._timeout
+        ev = self._event_queue.get(timeout=timeout)
+        if check_error and ev.name == "DC_EVENT_ERROR":
+            raise ValueError(str(ev))
+        return ev
+
+    def ensure_event_not_queued(self, event_name_regex):
+        __tracebackhide__ = True
+        rex = re.compile("(?:{}).*".format(event_name_regex))
+        while 1:
+            try:
+                ev = self._event_queue.get(False)
+            except Empty:
+                break
+            else:
+                assert not rex.match(ev.name), "event found {}".format(ev)
+
+    def get_matching(self, event_name_regex, check_error=True, timeout=None):
+        self.account.ac_log_line("-- waiting for event with regex: {} --".format(event_name_regex))
+        rex = re.compile("(?:{}).*".format(event_name_regex))
+        while 1:
+            ev = self.get(timeout=timeout, check_error=check_error)
+            if rex.match(ev.name):
+                return ev
+
+    def get_info_matching(self, regex):
+        rex = re.compile("(?:{}).*".format(regex))
+        while 1:
+            ev = self.get_matching("DC_EVENT_INFO")
+            if rex.match(ev.data2):
+                return ev
+
+    def wait_next_incoming_message(self):
+        """ wait for and return next incoming message. """
+        ev = self.get_matching("DC_EVENT_INCOMING_MSG")
+        return self.account.get_message_by_id(ev.data2)
+
+    def wait_next_messages_changed(self):
+        """ wait for and return next message-changed message or None
+        if the event contains no msgid"""
+        ev = self.get_matching("DC_EVENT_MSGS_CHANGED")
+        if ev.data2 > 0:
+            return self.account.get_message_by_id(ev.data2)

python/src/deltachat/events.py

@@ -1,217 +0,0 @@
-import threading
-import time
-import re
-from queue import Queue, Empty
-
-import deltachat
-from .hookspec import account_hookimpl
-from contextlib import contextmanager
-from .capi import ffi, lib
-from .message import map_system_message
-from .cutil import from_dc_charpointer
-
-
-class FFIEvent:
-    def __init__(self, name, data1, data2):
-        self.name = name
-        self.data1 = data1
-        self.data2 = data2
-
-    def __str__(self):
-        return "{name} data1={data1} data2={data2}".format(**self.__dict__)
-
-
-class FFIEventLogger:
-    """ If you register an instance of this logger with an Account
-    you'll get all ffi-events printed.
-    """
-    # to prevent garbled logging
-    _loglock = threading.RLock()
-
-    def __init__(self, account, logid):
-        """
-        :param logid: an optional logging prefix that should be used with
-                      the default internal logging.
-        """
-        self.account = account
-        self.logid = logid
-        self.init_time = time.time()
-
-    @account_hookimpl
-    def ac_process_ffi_event(self, ffi_event):
-        self.account.log(str(ffi_event))
-
-    @account_hookimpl
-    def ac_log_line(self, message):
-        t = threading.currentThread()
-        tname = getattr(t, "name", t)
-        if tname == "MainThread":
-            tname = "MAIN"
-        elapsed = time.time() - self.init_time
-        locname = tname
-        if self.logid:
-            locname += "-" + self.logid
-        s = "{:2.2f} [{}] {}".format(elapsed, locname, message)
-        with self._loglock:
-            print(s, flush=True)
-
-
-class FFIEventTracker:
-    def __init__(self, account, timeout=None):
-        self.account = account
-        self._timeout = timeout
-        self._event_queue = Queue()
-
-    @account_hookimpl
-    def ac_process_ffi_event(self, ffi_event):
-        self._event_queue.put(ffi_event)
-
-    def set_timeout(self, timeout):
-        self._timeout = timeout
-
-    def consume_events(self, check_error=True):
-        while not self._event_queue.empty():
-            self.get(check_error=check_error)
-
-    def get(self, timeout=None, check_error=True):
-        timeout = timeout if timeout is not None else self._timeout
-        ev = self._event_queue.get(timeout=timeout)
-        if check_error and ev.name == "DC_EVENT_ERROR":
-            raise ValueError("unexpected event: {}".format(ev))
-        return ev
-
-    def iter_events(self, timeout=None, check_error=True):
-        while 1:
-            yield self.get(timeout=timeout, check_error=check_error)
-
-    def get_matching(self, event_name_regex, check_error=True, timeout=None):
-        rex = re.compile("(?:{}).*".format(event_name_regex))
-        for ev in self.iter_events(timeout=timeout, check_error=check_error):
-            if rex.match(ev.name):
-                return ev
-
-    def get_info_matching(self, regex):
-        rex = re.compile("(?:{}).*".format(regex))
-        while 1:
-            ev = self.get_matching("DC_EVENT_INFO")
-            if rex.match(ev.data2):
-                return ev
-
-    def ensure_event_not_queued(self, event_name_regex):
-        __tracebackhide__ = True
-        rex = re.compile("(?:{}).*".format(event_name_regex))
-        while 1:
-            try:
-                ev = self._event_queue.get(False)
-            except Empty:
-                break
-            else:
-                assert not rex.match(ev.name), "event found {}".format(ev)
-
-    def wait_securejoin_inviter_progress(self, target):
-        while 1:
-            event = self.get_matching("DC_EVENT_SECUREJOIN_INVITER_PROGRESS")
-            if event.data2 >= target:
-                print("** SECUREJOINT-INVITER PROGRESS {}".format(target), self.account)
-                break
-
-    def wait_next_incoming_message(self):
-        """ wait for and return next incoming message. """
-        ev = self.get_matching("DC_EVENT_INCOMING_MSG")
-        return self.account.get_message_by_id(ev.data2)
-
-    def wait_next_messages_changed(self):
-        """ wait for and return next message-changed message or None
-        if the event contains no msgid"""
-        ev = self.get_matching("DC_EVENT_MSGS_CHANGED")
-        if ev.data2 > 0:
-            return self.account.get_message_by_id(ev.data2)
-
-
-class EventThread(threading.Thread):
-    """ Event Thread for an account.
-
-    With each Account init this callback thread is started.
-    """
-    def __init__(self, account):
-        self.account = account
-        super(EventThread, self).__init__(name="events")
-        self.setDaemon(True)
-        self.start()
-
-    @contextmanager
-    def log_execution(self, message):
-        self.account.log(message + " START")
-        yield
-        self.account.log(message + " FINISHED")
-
-    def wait(self):
-        if self == threading.current_thread():
-            # we are in the callback thread and thus cannot
-            # wait for the thread-loop to finish.
-            return
-        self.join()
-
-    def run(self):
-        """ get and run events until shutdown. """
-        with self.log_execution("EVENT THREAD"):
-            self._inner_run()
-
-    def _inner_run(self):
-        event_emitter = ffi.gc(
-            lib.dc_get_event_emitter(self.account._dc_context),
-            lib.dc_event_emitter_unref,
-        )
-        while 1:
-            event = lib.dc_get_next_event(event_emitter)
-            if event == ffi.NULL:
-                break
-            evt = lib.dc_event_get_id(event)
-            data1 = lib.dc_event_get_data1_int(event)
-            # the following code relates to the deltachat/_build.py's helper
-            # function which provides us signature info of an event call
-            evt_name = deltachat.get_dc_event_name(evt)
-            if lib.dc_event_has_string_data(evt):
-                data2 = from_dc_charpointer(lib.dc_event_get_data2_str(event))
-            else:
-                data2 = lib.dc_event_get_data2_int(event)
-
-            lib.dc_event_unref(event)
-            ffi_event = FFIEvent(name=evt_name, data1=data1, data2=data2)
-            try:
-                self.account._pm.hook.ac_process_ffi_event(account=self, ffi_event=ffi_event)
-                for name, kwargs in self._map_ffi_event(ffi_event):
-                    self.account.log("calling hook name={} kwargs={}".format(name, kwargs))
-                    hook = getattr(self.account._pm.hook, name)
-                    hook(**kwargs)
-            except Exception:
-                if self.account._dc_context is not None:
-                    raise
-
-    def _map_ffi_event(self, ffi_event):
-        name = ffi_event.name
-        account = self.account
-        if name == "DC_EVENT_CONFIGURE_PROGRESS":
-            data1 = ffi_event.data1
-            if data1 == 0 or data1 == 1000:
-                success = data1 == 1000
-                yield "ac_configure_completed", dict(success=success)
-        elif name == "DC_EVENT_INCOMING_MSG":
-            msg = account.get_message_by_id(ffi_event.data2)
-            yield map_system_message(msg) or ("ac_incoming_message", dict(message=msg))
-        elif name == "DC_EVENT_MSGS_CHANGED":
-            if ffi_event.data2 != 0:
-                msg = account.get_message_by_id(ffi_event.data2)
-                if msg.is_outgoing():
-                    res = map_system_message(msg)
-                    if res and res[0].startswith("ac_member"):
-                        yield res
-                    yield "ac_outgoing_message", dict(message=msg)
-                elif msg.is_in_fresh():
-                    yield map_system_message(msg) or ("ac_incoming_message", dict(message=msg))
-        elif name == "DC_EVENT_MSG_DELIVERED":
-            msg = account.get_message_by_id(ffi_event.data2)
-            yield "ac_message_delivered", dict(message=msg)
-        elif name == "DC_EVENT_CHAT_MODIFIED":
-            chat = account.get_chat_by_id(ffi_event.data1)
-            yield "ac_chat_modified", dict(chat=chat)

python/src/deltachat/hookspec.py

@@ -15,9 +15,8 @@ global_hookimpl = pluggy.HookimplMarker(global_spec_name)
 class PerAccount:
     """ per-Account-instance hook specifications.
 
-    All hooks are executed in a dedicated Event thread.
-    Hooks are not allowed to block/last long as this
-    blocks overall event processing on the python side.
+    Except for ac_process_ffi_event all hooks are executed
+    in the thread which calls Account.wait_shutdown().
     """
     @classmethod
     def _make_plugin_manager(cls):
@@ -89,5 +88,5 @@ class Global:
         """ called when `Account::__init__()` function starts executing. """
 
     @global_hookspec
-    def dc_account_after_shutdown(self, account):
+    def dc_account_after_shutdown(self, account, dc_context):
         """ Called after the account has been shutdown. """

python/src/deltachat/iothreads.py

@@ -0,0 +1,106 @@
+
+import threading
+import time
+
+from contextlib import contextmanager
+
+from .capi import lib
+
+
+class IOThreads:
+    def __init__(self, account):
+        self.account = account
+        self._dc_context = account._dc_context
+        self._thread_quitflag = False
+        self._name2thread = {}
+
+    def is_started(self):
+        return len(self._name2thread) > 0
+
+    def start(self, callback_thread):
+        assert not self.is_started()
+        self._start_one_thread("inbox", self.imap_thread_run)
+        self._start_one_thread("smtp", self.smtp_thread_run)
+
+        if callback_thread:
+            self._start_one_thread("cb", self.cb_thread_run)
+
+        if int(self.account.get_config("mvbox_watch")):
+            self._start_one_thread("mvbox", self.mvbox_thread_run)
+
+        if int(self.account.get_config("sentbox_watch")):
+            self._start_one_thread("sentbox", self.sentbox_thread_run)
+
+    def _start_one_thread(self, name, func):
+        self._name2thread[name] = t = threading.Thread(target=func, name=name)
+        t.setDaemon(1)
+        t.start()
+
+    @contextmanager
+    def log_execution(self, message):
+        self.account.ac_log_line(message + " START")
+        yield
+        self.account.ac_log_line(message + " FINISHED")
+
+    def stop(self, wait=False):
+        self._thread_quitflag = True
+
+        # Workaround for a race condition. Make sure that thread is
+        # not in between checking for quitflag and entering idle.
+        time.sleep(0.5)
+
+        lib.dc_interrupt_imap_idle(self._dc_context)
+        lib.dc_interrupt_smtp_idle(self._dc_context)
+        if "mvbox" in self._name2thread:
+            lib.dc_interrupt_mvbox_idle(self._dc_context)
+        if "sentbox" in self._name2thread:
+            lib.dc_interrupt_sentbox_idle(self._dc_context)
+        if wait:
+            for name, thread in self._name2thread.items():
+                if thread != threading.currentThread():
+                    thread.join()
+
+    def cb_thread_run(self):
+        with self.log_execution("CALLBACK THREAD START"):
+            it = self.account.iter_events()
+            while not self._thread_quitflag:
+                try:
+                    ev = next(it)
+                except StopIteration:
+                    break
+                self.account.ac_log_line("calling hook name={} kwargs={}".format(ev.name, ev.kwargs))
+                ev.call_hook()
+
+    def imap_thread_run(self):
+        with self.log_execution("INBOX THREAD START"):
+            while not self._thread_quitflag:
+                lib.dc_perform_imap_jobs(self._dc_context)
+                if not self._thread_quitflag:
+                    lib.dc_perform_imap_fetch(self._dc_context)
+                if not self._thread_quitflag:
+                    lib.dc_perform_imap_idle(self._dc_context)
+
+    def mvbox_thread_run(self):
+        with self.log_execution("MVBOX THREAD"):
+            while not self._thread_quitflag:
+                lib.dc_perform_mvbox_jobs(self._dc_context)
+                if not self._thread_quitflag:
+                    lib.dc_perform_mvbox_fetch(self._dc_context)
+                if not self._thread_quitflag:
+                    lib.dc_perform_mvbox_idle(self._dc_context)
+
+    def sentbox_thread_run(self):
+        with self.log_execution("SENTBOX THREAD"):
+            while not self._thread_quitflag:
+                lib.dc_perform_sentbox_jobs(self._dc_context)
+                if not self._thread_quitflag:
+                    lib.dc_perform_sentbox_fetch(self._dc_context)
+                if not self._thread_quitflag:
+                    lib.dc_perform_sentbox_idle(self._dc_context)
+
+    def smtp_thread_run(self):
+        with self.log_execution("SMTP THREAD"):
+            while not self._thread_quitflag:
+                lib.dc_perform_smtp_jobs(self._dc_context)
+                if not self._thread_quitflag:
+                    lib.dc_perform_smtp_idle(self._dc_context)

python/src/deltachat/message.py

@@ -16,7 +16,8 @@ class Message(object):
     """
     def __init__(self, account, dc_msg):
         self.account = account
-        assert isinstance(self.account._dc_context, ffi.CData)
+        self._dc_context = account._dc_context
+        assert isinstance(self._dc_context, ffi.CData)
         assert isinstance(dc_msg, ffi.CData)
         assert dc_msg != ffi.NULL
         self._dc_msg = dc_msg
@@ -28,10 +29,8 @@ class Message(object):
 
     def __repr__(self):
         c = self.get_sender_contact()
-        typ = "outgoing" if self.is_outgoing() else "incoming"
-        return "<Message {} sys={} {} id={} sender={}/{} chat={}/{}>".format(
-            typ, self.is_system_message(), repr(self.text[:10]),
-            self.id, c.id, c.addr, self.chat.id, self.chat.get_name())
+        return "<Message id={} sender={}/{} outgoing={} chat={}/{}>".format(
+            self.id, c.id, c.addr, self.is_outgoing(), self.chat.id, self.chat.get_name())
 
     @classmethod
     def from_db(cls, account, id):
@@ -59,7 +58,7 @@ class Message(object):
         """
         self.account.create_chat_by_message(self)
         self._dc_msg = ffi.gc(
-                lib.dc_get_msg(self.account._dc_context, self.id),
+                lib.dc_get_msg(self._dc_context, self.id),
                 lib.dc_msg_unref
         )
 
@@ -96,7 +95,7 @@ class Message(object):
 
     def is_system_message(self):
         """ return True if this message is a system/info message. """
-        return bool(lib.dc_msg_is_info(self._dc_msg))
+        return lib.dc_msg_is_info(self._dc_msg)
 
     def is_setup_message(self):
         """ return True if this message is a setup message. """
@@ -119,12 +118,12 @@ class Message(object):
 
         The text is multiline and may contain eg. the raw text of the message.
         """
-        return from_dc_charpointer(lib.dc_get_msg_info(self.account._dc_context, self.id))
+        return from_dc_charpointer(lib.dc_get_msg_info(self._dc_context, self.id))
 
     def continue_key_transfer(self, setup_code):
         """ extract key and use it as primary key for this account. """
         res = lib.dc_continue_key_transfer(
-                self.account._dc_context,
+                self._dc_context,
                 self.id,
                 as_dc_charpointer(setup_code)
         )
@@ -159,7 +158,7 @@ class Message(object):
         :returns: email-mime message object (with headers only, no body).
         """
         import email.parser
-        mime_headers = lib.dc_get_mime_headers(self.account._dc_context, self.id)
+        mime_headers = lib.dc_get_mime_headers(self._dc_context, self.id)
         if mime_headers:
             s = ffi.string(ffi.gc(mime_headers, lib.dc_str_unref))
             if isinstance(s, bytes):
@@ -202,7 +201,7 @@ class Message(object):
         else:
             # load message from db to get a fresh/current state
             dc_msg = ffi.gc(
-                lib.dc_get_msg(self.account._dc_context, self.id),
+                lib.dc_get_msg(self._dc_context, self.id),
                 lib.dc_msg_unref
             )
         return lib.dc_msg_get_state(dc_msg)

python/src/deltachat/testplugin.py

@@ -13,8 +13,10 @@ import pytest
 import requests
 
 from . import Account, const
+from .tracker import ConfigureTracker
 from .capi import lib
-from .events import FFIEventLogger, FFIEventTracker
+from .eventlogger import FFIEventLogger, FFIEventTracker
+from _pytest.monkeypatch import MonkeyPatch
 from _pytest._code import Source
 
 import deltachat
@@ -72,9 +74,6 @@ def pytest_configure(config):
 
         @pytest.hookimpl(hookwrapper=True)
         def pytest_runtest_setup(self, item):
-            if item.get_closest_marker("ignored"):
-                if not item.config.getvalue("ignored"):
-                    pytest.skip("use --ignored to run this test")
             self.enable_logging(item)
             yield
             self.disable_logging(item)
@@ -100,16 +99,18 @@ def pytest_report_header(config, startdir):
     summary = []
 
     t = tempfile.mktemp()
+    m = MonkeyPatch()
     try:
+        m.setattr(sys.stdout, "write", lambda x: len(x))
         ac = Account(t)
         info = ac.get_info()
         ac.shutdown()
     finally:
+        m.undo()
         os.remove(t)
-    summary.extend(['Deltachat core={} sqlite={} journal_mode={}'.format(
+    summary.extend(['Deltachat core={} sqlite={}'.format(
          info['deltachat_core_version'],
          info['sqlite_version'],
-         info['journal_mode'],
      )])
 
     cfg = config.option.liveconfig
@@ -230,6 +231,7 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig, data):
         def make_account(self, path, logid, quiet=False):
             ac = Account(path, logging=self._logging)
             ac._evtracker = ac.add_account_plugin(FFIEventTracker(ac))
+            ac._configtracker = ac.add_account_plugin(ConfigureTracker())
             ac.addr = ac.get_self_contact().addr
             if not quiet:
                 ac.add_account_plugin(FFIEventLogger(ac, logid=logid))
@@ -301,23 +303,22 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig, data):
             configdict["mvbox_move"] = str(int(move))
             configdict["sentbox_watch"] = str(int(sentbox))
             ac.update_config(configdict)
-            ac.configure()
+            ac.start()
             return ac
 
         def get_one_online_account(self, pre_generated_key=True, mvbox=False, move=False):
             ac1 = self.get_online_configuring_account(
                 pre_generated_key=pre_generated_key, mvbox=mvbox, move=move)
-            ac1.wait_configure_finish()
-            ac1.start_io()
+            ac1._configtracker.wait_imap_connected()
+            ac1._configtracker.wait_smtp_connected()
+            ac1._configtracker.wait_finish()
             return ac1
 
         def get_two_online_accounts(self, move=False, quiet=False):
             ac1 = self.get_online_configuring_account(move=True, quiet=quiet)
             ac2 = self.get_online_configuring_account(quiet=quiet)
-            ac1.wait_configure_finish()
-            ac1.start_io()
-            ac2.wait_configure_finish()
-            ac2.start_io()
+            ac1._configtracker.wait_finish()
+            ac2._configtracker.wait_finish()
             return ac1, ac2
 
         def get_many_online_accounts(self, num, move=True, quiet=True):
@@ -325,7 +326,6 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig, data):
                         for i in range(num)]
             for acc in accounts:
                 acc._configtracker.wait_finish()
-                acc.start_io()
             return accounts
 
         def clone_online_account(self, account, pre_generated_key=True):
@@ -343,7 +343,7 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig, data):
                 mvbox_move=account.get_config("mvbox_move"),
                 sentbox_watch=account.get_config("sentbox_watch"),
             ))
-            ac.configure()
+            ac.start()
             return ac
 
         def run_bot_process(self, module, ffi=True):
@@ -400,7 +400,6 @@ class BotProcess:
                     break
                 line = line.strip()
                 self.stdout_queue.put(line)
-                print("bot-stdout: ", line)
         finally:
             self.stdout_queue.put(None)
 

python/src/deltachat/tracker.py

@@ -18,7 +18,7 @@ class ImexTracker:
         if ffi_event.name == "DC_EVENT_IMEX_PROGRESS":
             self._imex_events.put(ffi_event.data1)
         elif ffi_event.name == "DC_EVENT_IMEX_FILE_WRITTEN":
-            self._imex_events.put(ffi_event.data2)
+            self._imex_events.put(ffi_event.data1)
 
     def wait_finish(self, progress_timeout=60):
         """ Return list of written files, raise ValueError if ExportFailed. """
@@ -45,7 +45,6 @@ class ConfigureTracker:
         self._smtp_finished = Event()
         self._imap_finished = Event()
         self._ffi_events = []
-        self._progress = Queue()
 
     @account_hookimpl
     def ac_process_ffi_event(self, ffi_event):
@@ -54,8 +53,6 @@ class ConfigureTracker:
             self._smtp_finished.set()
         elif ffi_event.name == "DC_EVENT_IMAP_CONNECTED":
             self._imap_finished.set()
-        elif ffi_event.name == "DC_EVENT_CONFIGURE_PROGRESS":
-            self._progress.put(ffi_event.data1)
 
     @account_hookimpl
     def ac_configure_completed(self, success):
@@ -69,12 +66,6 @@ class ConfigureTracker:
         """ wait until smtp is configured. """
         self._imap_finished.wait()
 
-    def wait_progress(self, data1=None):
-        while 1:
-            evdata = self._progress.get()
-            if data1 is None or evdata == data1:
-                break
-
     def wait_finish(self):
         """ wait until configure is completed.
 

python/tests/auditwheels.py

@@ -10,6 +10,4 @@ if __name__ == "__main__":
     for relpath in os.listdir(workspacedir):
         if relpath.startswith("deltachat"):
             p = os.path.join(workspacedir, relpath)
-            subprocess.check_call(
-                ["auditwheel", "repair", p, "-w", workspacedir,
-                 "--plat", "manylinux2014_x86_64"])
+            subprocess.check_call(["auditwheel", "repair", p, "-w", workspacedir])

python/tests/conftest.py

@@ -0,0 +1,18 @@
+from __future__ import print_function
+
+
+def wait_configuration_progress(account, min_target, max_target=1001):
+    min_target = min(min_target, max_target)
+    while 1:
+        event = account._evtracker.get_matching("DC_EVENT_CONFIGURE_PROGRESS")
+        if event.data1 >= min_target and event.data1 <= max_target:
+            print("** CONFIG PROGRESS {}".format(min_target), account)
+            break
+
+
+def wait_securejoin_inviter_progress(account, target):
+    while 1:
+        event = account._evtracker.get_matching("DC_EVENT_SECUREJOIN_INVITER_PROGRESS")
+        if event.data2 >= target:
+            print("** SECUREJOINT-INVITER PROGRESS {}".format(target), account)
+            break

python/tests/stress_test_db.py

@@ -1,23 +1,18 @@
-
 import time
-import threading
-import pytest
 import os
-from queue import Queue, Empty
+from queue import Queue
 
 import deltachat
 
 
 def test_db_busy_error(acfactory, tmpdir):
     starttime = time.time()
-    log_lock = threading.RLock()
 
     def log(string):
-        with log_lock:
-            print("%3.2f %s" % (time.time() - starttime, string))
+        print("%3.2f %s" % (time.time() - starttime, string))
 
     # make a number of accounts
-    accounts = acfactory.get_many_online_accounts(3, quiet=True)
+    accounts = acfactory.get_many_online_accounts(5, quiet=False)
     log("created %s accounts" % len(accounts))
 
     # put a bigfile into each account
@@ -41,7 +36,7 @@ def test_db_busy_error(acfactory, tmpdir):
     # each replier receives all events and sends report events to receive_queue
     repliers = []
     for acc in accounts:
-        replier = AutoReplier(acc, log=log, num_send=500, num_bigfiles=5, report_func=report_func)
+        replier = AutoReplier(acc, num_send=1000, num_bigfiles=0, report_func=report_func)
         acc.add_account_plugin(replier)
         repliers.append(replier)
 
@@ -51,85 +46,60 @@ def test_db_busy_error(acfactory, tmpdir):
 
     alive_count = len(accounts)
     while alive_count > 0:
-        try:
-            replier, report_type, report_args = report_queue.get(timeout=10)
-        except Empty:
-            log("timeout waiting for next event")
-            pytest.fail("timeout exceeded")
+        replier, report_type, report_args = report_queue.get(10)
+        addr = replier.account.get_self_contact().addr
+        assert addr
         if report_type == ReportType.exit:
-            replier.log("EXIT")
+            alive_count -= 1
+            log("{} EXIT -- remaining: {}".format(addr, alive_count))
+            replier.account.shutdown(wait=True)
+        elif report_type == ReportType.message_sent:
+            log("{} sent message: {}".format(addr, report_args[0].text))
+        elif report_type == ReportType.message_incoming:
+            log("{} incoming message: {}".format(addr, report_args[0].text))
         elif report_type == ReportType.ffi_error:
-            replier.log("ERROR: {}".format(report_args[0]))
-        elif report_type == ReportType.message_echo:
-            continue
-        else:
-            raise ValueError("{} unknown report type {}, args={}".format(
-                addr, report_type, report_args
-            ))
-        alive_count -= 1
-        replier.log("shutting down")
-        replier.account.shutdown()
-        replier.log("shut down complete, remaining={}".format(alive_count))
+            log("{} ERROR: {}".format(addr, report_args[0]))
+            replier.account.shutdown(wait=True)
+            alive_count -= 1
 
 
 class ReportType:
     exit = "exit"
+    message_sent = "message-sent"
     ffi_error = "ffi-error"
-    message_echo = "message-echo"
+    message_incoming = "message-incoming"
 
 
 class AutoReplier:
-    def __init__(self, account, log, num_send, num_bigfiles, report_func):
+    def __init__(self, account, report_func, num_send, num_bigfiles):
         self.account = account
-        self._log = log
         self.report_func = report_func
         self.num_send = num_send
         self.num_bigfiles = num_bigfiles
         self.current_sent = 0
-        self.addr = self.account.get_self_contact().addr
-
-        self._thread = threading.Thread(
-            name="Stats{}".format(self.account),
-            target=self.thread_stats
-        )
-        self._thread.setDaemon(True)
-        self._thread.start()
-
-    def log(self, message):
-        self._log("{} {}".format(self.addr, message))
-
-    def thread_stats(self):
-        # XXX later use, for now we just quit
-        return
-        while 1:
-            time.sleep(1.0)
-            break
 
     @deltachat.account_hookimpl
     def ac_incoming_message(self, message):
         if self.current_sent >= self.num_send:
-            self.report_func(self, ReportType.exit)
             return
         message.accept_sender_contact()
         message.mark_seen()
-        self.log("incoming message: {}".format(message))
+        self.report_func(self, ReportType.message_incoming, message)
 
         self.current_sent += 1
         # we are still alive, let's send a reply
-        if self.num_bigfiles and self.current_sent % (self.num_send / self.num_bigfiles) == 0:
+        if self.num_bigfiles and self.current_sent % self.num_bigfiles == 0:
             message.chat.send_text("send big file as reply to: {}".format(message.text))
             msg = message.chat.send_file(self.account.bigfile)
         else:
             msg = message.chat.send_text("got message id {}, small text reply".format(message.id))
             assert msg.text
-        self.log("message-sent: {}".format(msg))
-        self.report_func(self, ReportType.message_echo)
+        self.report_func(self, ReportType.message_sent, msg)
         if self.current_sent >= self.num_send:
             self.report_func(self, ReportType.exit)
             return
 
     @deltachat.account_hookimpl
     def ac_process_ffi_event(self, ffi_event):
-        self.log(ffi_event)
         if ffi_event.name == "DC_EVENT_ERROR":
             self.report_func(self, ReportType.ffi_error, ffi_event)

python/tests/test_account.py

@@ -7,6 +7,8 @@ from deltachat import const, Account
 from deltachat.message import Message
 from deltachat.hookspec import account_hookimpl
 from datetime import datetime, timedelta
+from conftest import (wait_configuration_progress,
+                      wait_securejoin_inviter_progress)
 
 
 @pytest.mark.parametrize("msgtext,res", [
@@ -396,9 +398,11 @@ class TestOfflineChat:
         with bin.open("w") as f:
             f.write("\00123" * 10000)
         msg = chat.send_file(bin.strpath)
+
         contact = msg.get_sender_contact()
         assert contact == ac1.get_self_contact()
         assert not backupdir.listdir()
+
         path = ac1.export_all(backupdir.strpath)
         assert os.path.exists(path)
         ac2 = acfactory.get_unconfigured_account()
@@ -471,17 +475,8 @@ class TestOfflineChat:
         num_contacts = len(chat.get_contacts())
         assert num_contacts == 11
 
-        # let's make sure the events perform plugin hooks
-        def wait_events(cond):
-            now = time.time()
-            while time.time() < now + 5:
-                if cond():
-                    break
-                time.sleep(0.1)
-            else:
-                pytest.fail("failed to get events")
-
-        wait_events(lambda: len(in_list) == 10)
+        # perform plugin hooks
+        ac1._handle_current_events()
 
         assert len(in_list) == 10
         chat_contacts = chat.get_contacts()
@@ -500,7 +495,7 @@ class TestOfflineChat:
         chat.remove_contact(contacts[3])
         assert len(chat.get_contacts()) == 9
 
-        wait_events(lambda: len(in_list) == 2)
+        ac1._handle_current_events()
         assert len(in_list) == 2
         assert in_list[0][0] == "removed"
         assert in_list[0][1] == chat
@@ -519,6 +514,11 @@ class TestOnlineAccount:
             ac2.create_chat_by_contact(ac2.create_contact(email=ac1.get_config("addr")))
         return chat
 
+    def test_double_iter_events(self, acfactory):
+        ac1 = acfactory.get_one_online_account()
+        with pytest.raises(RuntimeError):
+            next(ac1.iter_events())
+
     @pytest.mark.ignored
     def test_configure_generate_key(self, acfactory, lp):
         # A slow test which will generate new keys.
@@ -532,10 +532,8 @@ class TestOnlineAccount:
         )
         # rsa key gen can be slow especially on CI, adjust timeout
         ac1._evtracker.set_timeout(120)
-        ac1.wait_configure_finish()
-        ac1.start_io()
-        ac2.wait_configure_finish()
-        ac2.start_io()
+        wait_configuration_progress(ac1, 1000)
+        wait_configuration_progress(ac2, 1000)
         chat = self.get_chat(ac1, ac2, both_created=True)
 
         lp.sec("ac1: send unencrypted message to ac2")
@@ -564,16 +562,12 @@ class TestOnlineAccount:
 
     def test_configure_canceled(self, acfactory):
         ac1 = acfactory.get_online_configuring_account()
-        ac1._configtracker.wait_progress()
+        wait_configuration_progress(ac1, 200)
         ac1.stop_ongoing()
-        try:
-            ac1.wait_configure_finish()
-        except Exception:
-            pass
+        wait_configuration_progress(ac1, 0, 0)
 
     def test_export_import_self_keys(self, acfactory, tmpdir):
         ac1, ac2 = acfactory.get_two_online_accounts()
-
         dir = tmpdir.mkdir("exportdir")
         export_files = ac1.export_self_keys(dir.strpath)
         assert len(export_files) == 2
@@ -590,12 +584,9 @@ class TestOnlineAccount:
         # are copied to it via BCC.
         ac1_clone = acfactory.clone_online_account(ac1)
 
-        ac1.wait_configure_finish()
-        ac1.start_io()
-        ac2.wait_configure_finish()
-        ac2.start_io()
-        ac1_clone.wait_configure_finish()
-        ac1_clone.start_io()
+        wait_configuration_progress(ac1, 1000)
+        wait_configuration_progress(ac2, 1000)
+        wait_configuration_progress(ac1_clone, 1000)
 
         chat = self.get_chat(ac1, ac2)
 
@@ -699,12 +690,10 @@ class TestOnlineAccount:
         ac2 = acfactory.get_online_configuring_account()
 
         lp.sec("ac2: waiting for configuration")
-        ac2.wait_configure_finish()
-        ac2.start_io()
+        wait_configuration_progress(ac2, 1000)
 
         lp.sec("ac1: waiting for configuration")
-        ac1.wait_configure_finish()
-        ac1.start_io()
+        wait_configuration_progress(ac1, 1000)
 
         lp.sec("ac1: send message and wait for ac2 to receive it")
         chat = self.get_chat(ac1, ac2)
@@ -716,10 +705,8 @@ class TestOnlineAccount:
     def test_move_works(self, acfactory):
         ac1 = acfactory.get_online_configuring_account()
         ac2 = acfactory.get_online_configuring_account(mvbox=True, move=True)
-        ac2.wait_configure_finish()
-        ac2.start_io()
-        ac1.wait_configure_finish()
-        ac1.start_io()
+        wait_configuration_progress(ac2, 1000)
+        wait_configuration_progress(ac1, 1000)
         chat = self.get_chat(ac1, ac2)
         chat.send_text("message1")
         ev = ac2._evtracker.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
@@ -730,11 +717,8 @@ class TestOnlineAccount:
         ac1 = acfactory.get_online_configuring_account(mvbox=True, move=True)
         ac1.set_config("bcc_self", "1")
         ac2 = acfactory.get_online_configuring_account()
-        ac2.wait_configure_finish()
-        ac2.start_io()
-        ac1.wait_configure_finish()
-        ac1.start_io()
-
+        wait_configuration_progress(ac2, 1000)
+        wait_configuration_progress(ac1, 1000)
         chat = self.get_chat(ac1, ac2)
         chat.send_text("message1")
         chat.send_text("message2")
@@ -809,9 +793,8 @@ class TestOnlineAccount:
         ac1.empty_server_folders(inbox=True, mvbox=True)
         ev1 = ac1._evtracker.get_matching("DC_EVENT_IMAP_FOLDER_EMPTIED")
         ev2 = ac1._evtracker.get_matching("DC_EVENT_IMAP_FOLDER_EMPTIED")
-        boxes = [ev1.data2, ev2.data2]
-        boxes.remove("INBOX")
-        assert len(boxes) == 1 and boxes[0].endswith("DeltaChat")
+        boxes = sorted([ev1.data2, ev2.data2])
+        assert boxes == ["DeltaChat", "INBOX"]
 
     def test_send_and_receive_message_markseen(self, acfactory, lp):
         ac1, ac2 = acfactory.get_two_online_accounts()
@@ -1064,35 +1047,6 @@ class TestOnlineAccount:
         assert mime.get_all("From")
         assert mime.get_all("Received")
 
-    def test_send_mark_seen_clean_incoming_events(self, acfactory, lp, data):
-        ac1, ac2 = acfactory.get_two_online_accounts()
-        chat = self.get_chat(ac1, ac2, both_created=True)
-
-        message_queue = queue.Queue()
-
-        class InPlugin:
-            @account_hookimpl
-            def ac_incoming_message(self, message):
-                message_queue.put(message)
-
-        ac1.add_account_plugin(InPlugin())
-
-        lp.sec("sending one message from ac1 to ac2")
-        chat.send_text("hello")
-
-        lp.sec("ac2: waiting to receive")
-        msg = ac2._evtracker.wait_next_incoming_message()
-        assert msg.text == "hello"
-
-        lp.sec("ac2: mark seen {}".format(msg))
-        msg.mark_seen()
-
-        for ev in ac1._evtracker.iter_events():
-            if ev.name == "DC_EVENT_INCOMING_MSG":
-                pytest.fail("MDN arrived as regular incoming message")
-            elif ev.name == "DC_EVENT_MSG_READ":
-                break
-
     def test_send_and_receive_image(self, acfactory, lp, data):
         ac1, ac2 = acfactory.get_two_online_accounts()
         chat = self.get_chat(ac1, ac2)
@@ -1142,7 +1096,8 @@ class TestOnlineAccount:
         assert m == msg_in
 
     def test_import_export_online_all(self, acfactory, tmpdir, lp):
-        ac1 = acfactory.get_one_online_account()
+        ac1 = acfactory.get_online_configuring_account()
+        wait_configuration_progress(ac1, 1000)
 
         lp.sec("create some chat content")
         contact1 = ac1.create_contact("some1@hello.com", name="some1")
@@ -1190,11 +1145,8 @@ class TestOnlineAccount:
         # as of Jul2019
         ac1 = acfactory.get_online_configuring_account()
         ac2 = acfactory.clone_online_account(ac1)
-        ac2.wait_configure_finish()
-        ac2.start_io()
-        ac1.wait_configure_finish()
-        ac1.start_io()
-
+        wait_configuration_progress(ac2, 1000)
+        wait_configuration_progress(ac1, 1000)
         lp.sec("trigger ac setup message and return setupcode")
         assert ac1.get_info()["fingerprint"] != ac2.get_info()["fingerprint"]
         setup_code = ac1.initiate_key_transfer()
@@ -1216,10 +1168,8 @@ class TestOnlineAccount:
         ac1 = acfactory.get_online_configuring_account()
         ac2 = acfactory.clone_online_account(ac1)
         ac2._evtracker.set_timeout(30)
-        ac2.wait_configure_finish()
-        ac2.start_io()
-        ac1.wait_configure_finish()
-        ac1.start_io()
+        wait_configuration_progress(ac2, 1000)
+        wait_configuration_progress(ac1, 1000)
 
         lp.sec("trigger ac setup message but ignore")
         assert ac1.get_info()["fingerprint"] != ac2.get_info()["fingerprint"]
@@ -1245,7 +1195,7 @@ class TestOnlineAccount:
         lp.sec("ac2: start QR-code based setup contact protocol")
         ch = ac2.qr_setup_contact(qr)
         assert ch.id >= 10
-        ac1._evtracker.wait_securejoin_inviter_progress(1000)
+        wait_securejoin_inviter_progress(ac1, 1000)
 
     def test_qr_join_chat(self, acfactory, lp):
         ac1, ac2 = acfactory.get_two_online_accounts()
@@ -1254,12 +1204,11 @@ class TestOnlineAccount:
         qr = chat.get_join_qr()
         lp.sec("ac2: start QR-code based join-group protocol")
         ch = ac2.qr_join_chat(qr)
-        lp.sec("ac2: qr_join_chat() returned")
         assert ch.id >= 10
         # check that at least some of the handshake messages are deleted
         ac1._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
         ac2._evtracker.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
-        ac1._evtracker.wait_securejoin_inviter_progress(1000)
+        wait_securejoin_inviter_progress(ac1, 1000)
 
     def test_qr_verified_group_and_chatting(self, acfactory, lp):
         ac1, ac2 = acfactory.get_two_online_accounts()
@@ -1270,7 +1219,7 @@ class TestOnlineAccount:
         lp.sec("ac2: start QR-code based join-group protocol")
         chat2 = ac2.qr_join_chat(qr)
         assert chat2.id >= 10
-        ac1._evtracker.wait_securejoin_inviter_progress(1000)
+        wait_securejoin_inviter_progress(ac1, 1000)
 
         lp.sec("ac2: read member added message")
         msg = ac2._evtracker.wait_next_incoming_message()
@@ -1530,8 +1479,7 @@ class TestGroupStressTests:
         lp.sec("creating and configuring five accounts")
         accounts = [acfactory.get_online_configuring_account() for i in range(5)]
         for acc in accounts:
-            acc.wait_configure_finish()
-            acc.start_io()
+            wait_configuration_progress(acc, 1000)
         ac1 = accounts.pop()
 
         lp.sec("ac1: setting up contacts with 4 other members")
@@ -1624,9 +1572,6 @@ class TestGroupStressTests:
         # Message should be encrypted because keys of other members are gossiped
         assert msg.is_encrypted()
 
-        for account in accounts:
-            account.shutdown()
-
     def test_synchronize_member_list_on_group_rejoin(self, acfactory, lp):
         """
         Test that user recreates group member list when it joins the group again.
@@ -1638,8 +1583,7 @@ class TestGroupStressTests:
         lp.sec("creating and configuring five accounts")
         accounts = [acfactory.get_online_configuring_account() for i in range(3)]
         for acc in accounts:
-            acc.wait_configure_finish()
-            acc.start_io()
+            wait_configuration_progress(acc, 1000)
         ac1 = accounts.pop()
 
         lp.sec("ac1: setting up contacts with 2 other members")
@@ -1702,35 +1646,31 @@ class TestGroupStressTests:
 
         assert len(msg.chat.get_contacts()) == len(chat.get_contacts())
 
-        ac1.shutdown()
-        ac2.shutdown()
-        ac3.shutdown()
-
 
 class TestOnlineConfigureFails:
     def test_invalid_password(self, acfactory):
         ac1, configdict = acfactory.get_online_config()
         ac1.update_config(dict(addr=configdict["addr"], mail_pw="123"))
-        ac1.configure()
-        ac1._configtracker.wait_progress(500)
-        ac1._configtracker.wait_progress(0)
+        ac1.start()
+        wait_configuration_progress(ac1, 500)
         ev = ac1._evtracker.get_matching("DC_EVENT_ERROR_NETWORK")
         assert "cannot login" in ev.data2.lower()
+        wait_configuration_progress(ac1, 0, 0)
 
     def test_invalid_user(self, acfactory):
         ac1, configdict = acfactory.get_online_config()
         ac1.update_config(dict(addr="x" + configdict["addr"], mail_pw=configdict["mail_pw"]))
-        ac1.configure()
-        ac1._configtracker.wait_progress(500)
-        ac1._configtracker.wait_progress(0)
+        ac1.start()
+        wait_configuration_progress(ac1, 500)
         ev = ac1._evtracker.get_matching("DC_EVENT_ERROR_NETWORK")
         assert "cannot login" in ev.data2.lower()
+        wait_configuration_progress(ac1, 0, 0)
 
     def test_invalid_domain(self, acfactory):
         ac1, configdict = acfactory.get_online_config()
         ac1.update_config((dict(addr=configdict["addr"] + "x", mail_pw=configdict["mail_pw"])))
-        ac1.configure()
-        ac1._configtracker.wait_progress(500)
-        ac1._configtracker.wait_progress(0)
+        ac1.start()
+        wait_configuration_progress(ac1, 500)
         ev = ac1._evtracker.get_matching("DC_EVENT_ERROR_NETWORK")
         assert "could not connect" in ev.data2.lower()
+        wait_configuration_progress(ac1, 0, 0)

python/tests/test_increation.py

@@ -6,36 +6,24 @@ import shutil
 import pytest
 from filecmp import cmp
 
+from conftest import wait_configuration_progress
 from deltachat import const
 
 
-def wait_msg_delivered(account, msg_list):
-    """ wait for one or more MSG_DELIVERED events to match msg_list contents. """
-    msg_list = list(msg_list)
-    while msg_list:
-        ev = account._evtracker.get_matching("DC_EVENT_MSG_DELIVERED")
-        msg_list.remove((ev.data1, ev.data2))
-
-
-def wait_msgs_changed(account, msgs_list):
-    """ wait for one or more MSGS_CHANGED events to match msgs_list contents. """
-    account.log("waiting for msgs_list={}".format(msgs_list))
-    msgs_list = list(msgs_list)
-    while msgs_list:
-        ev = account._evtracker.get_matching("DC_EVENT_MSGS_CHANGED")
-        for i, (data1, data2) in enumerate(msgs_list):
-            if ev.data1 == data1:
-                if data2 is None or ev.data2 == data2:
-                    del msgs_list[i]
-                    break
-        else:
-            account.log("waiting mismatch data1={} data2={}".format(data1, data2))
-    return ev.data1, ev.data2
+def wait_msgs_changed(account, chat_id, msg_id=None):
+    ev = account._evtracker.get_matching("DC_EVENT_MSGS_CHANGED")
+    assert ev.data1 == chat_id
+    if msg_id is not None:
+        assert ev.data2 == msg_id
+    return ev.data2
 
 
 class TestOnlineInCreation:
     def test_increation_not_blobdir(self, tmpdir, acfactory, lp):
-        ac1, ac2 = acfactory.get_two_online_accounts()
+        ac1 = acfactory.get_online_configuring_account()
+        ac2 = acfactory.get_online_configuring_account()
+        wait_configuration_progress(ac1, 1000)
+        wait_configuration_progress(ac2, 1000)
 
         c2 = ac1.create_contact(email=ac2.get_config("addr"))
         chat = ac1.create_chat_by_contact(c2)
@@ -47,7 +35,10 @@ class TestOnlineInCreation:
             chat.prepare_message_file(src.strpath)
 
     def test_no_increation_copies_to_blobdir(self, tmpdir, acfactory, lp):
-        ac1, ac2 = acfactory.get_two_online_accounts()
+        ac1 = acfactory.get_online_configuring_account()
+        ac2 = acfactory.get_online_configuring_account()
+        wait_configuration_progress(ac1, 1000)
+        wait_configuration_progress(ac2, 1000)
 
         c2 = ac1.create_contact(email=ac2.get_config("addr"))
         chat = ac1.create_chat_by_contact(c2)
@@ -62,12 +53,15 @@ class TestOnlineInCreation:
         assert os.path.exists(blob_src), "file.txt not copied to blobdir"
 
     def test_forward_increation(self, acfactory, data, lp):
-        ac1, ac2 = acfactory.get_two_online_accounts()
+        ac1 = acfactory.get_online_configuring_account()
+        ac2 = acfactory.get_online_configuring_account()
+        wait_configuration_progress(ac1, 1000)
+        wait_configuration_progress(ac2, 1000)
 
         c2 = ac1.create_contact(email=ac2.get_config("addr"))
         chat = ac1.create_chat_by_contact(c2)
         assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
-        wait_msgs_changed(ac1, [(0, 0)])  # why no chat id?
+        wait_msgs_changed(ac1, 0, 0)  # why no chat id?
 
         lp.sec("create a message with a file in creation")
         orig = data.get_path("d.png")
@@ -76,16 +70,19 @@ class TestOnlineInCreation:
             fp.write("preparing")
         prepared_original = chat.prepare_message_file(path)
         assert prepared_original.is_out_preparing()
-        wait_msgs_changed(ac1, [(chat.id, prepared_original.id)])
+        wait_msgs_changed(ac1, chat.id, prepared_original.id)
 
         lp.sec("forward the message while still in creation")
         chat2 = ac1.create_group_chat("newgroup")
         chat2.add_contact(c2)
-        wait_msgs_changed(ac1, [(0, 0)])  # why not chat id?
+        wait_msgs_changed(ac1, 0, 0)  # why not chat id?
         ac1.forward_messages([prepared_original], chat2)
         # XXX there might be two EVENT_MSGS_CHANGED and only one of them
         # is the one caused by forwarding
-        _, forwarded_id = wait_msgs_changed(ac1, [(chat2.id, None)])
+        forwarded_id = wait_msgs_changed(ac1, chat2.id)
+        if forwarded_id == 0:
+            forwarded_id = wait_msgs_changed(ac1, chat2.id)
+            assert forwarded_id
         forwarded_msg = ac1.get_message_by_id(forwarded_id)
         assert forwarded_msg.is_out_preparing()
 
@@ -94,18 +91,20 @@ class TestOnlineInCreation:
         shutil.copyfile(orig, path)
         chat.send_prepared(prepared_original)
         assert prepared_original.is_out_pending() or prepared_original.is_out_delivered()
+        wait_msgs_changed(ac1, chat.id, prepared_original.id)
 
-        lp.sec("check that both forwarded and original message are proper.")
-        wait_msgs_changed(ac1, [(chat2.id, forwarded_id), (chat.id, prepared_original.id)])
-
+        lp.sec("expect the forwarded message to be sent now too")
+        wait_msgs_changed(ac1, chat2.id, forwarded_id)
         fwd_msg = ac1.get_message_by_id(forwarded_id)
         assert fwd_msg.is_out_pending() or fwd_msg.is_out_delivered()
 
-        lp.sec("wait for both messages to be delivered to SMTP")
-        wait_msg_delivered(ac1, [
-            (chat2.id, forwarded_id),
-            (chat.id, prepared_original.id)
-        ])
+        lp.sec("wait for the messages to be delivered to SMTP")
+        ev = ac1._evtracker.get_matching("DC_EVENT_MSG_DELIVERED")
+        assert ev.data1 == chat.id
+        assert ev.data2 == prepared_original.id
+        ev = ac1._evtracker.get_matching("DC_EVENT_MSG_DELIVERED")
+        assert ev.data1 == chat2.id
+        assert ev.data2 == forwarded_id
 
         lp.sec("wait1 for original or forwarded messages to arrive")
         ev1 = ac2._evtracker.get_matching("DC_EVENT_MSGS_CHANGED")

python/tests/test_lowlevel.py

@@ -1,52 +1,75 @@
 from __future__ import print_function
-
-from queue import Queue
-from deltachat import capi, cutil, const
+from deltachat import capi, cutil, const, set_context_callback, clear_context_callback
 from deltachat import register_global_plugin
 from deltachat.hookspec import global_hookimpl
 from deltachat.capi import ffi
 from deltachat.capi import lib
-# from deltachat.account import EventLogger
 
 
 def test_empty_context():
     ctx = capi.lib.dc_context_new(capi.ffi.NULL, capi.ffi.NULL, capi.ffi.NULL)
-    capi.lib.dc_context_unref(ctx)
+    capi.lib.dc_close(ctx)
+
+
+def test_callback_None2int():
+    ctx = capi.lib.dc_context_new(capi.lib.py_dc_callback, ffi.NULL, ffi.NULL)
+    set_context_callback(ctx, lambda *args: None)
+    capi.lib.dc_close(ctx)
+    clear_context_callback(ctx)
 
 
 def test_dc_close_events(tmpdir, acfactory):
     ac1 = acfactory.get_unconfigured_account()
 
     # register after_shutdown function
-    shutdowns = Queue()
+    shutdowns = []
 
     class ShutdownPlugin:
         @global_hookimpl
         def dc_account_after_shutdown(self, account):
             assert account._dc_context is None
-            shutdowns.put(account)
+            shutdowns.append(account)
     register_global_plugin(ShutdownPlugin())
     assert hasattr(ac1, "_dc_context")
     ac1.shutdown()
-    shutdowns.get(timeout=2)
+    assert shutdowns == [ac1]
+
+    def find(info_string):
+        evlog = ac1._evtracker
+        while 1:
+            ev = evlog.get_matching("DC_EVENT_INFO", check_error=False)
+            data2 = ev.data2
+            if info_string in data2:
+                return
+            else:
+                print("skipping event", ev)
+
+    find("disconnecting inbox-thread")
+    find("disconnecting sentbox-thread")
+    find("disconnecting mvbox-thread")
+    find("disconnecting SMTP")
+    find("Database closed")
 
 
 def test_wrong_db(tmpdir):
+    dc_context = ffi.gc(
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
+        lib.dc_context_unref,
+    )
     p = tmpdir.join("hello.db")
     # write an invalid database file
     p.write("x123" * 10)
-
-    assert ffi.NULL == lib.dc_context_new(ffi.NULL, p.strpath.encode("ascii"), ffi.NULL)
+    assert not lib.dc_open(dc_context, p.strpath.encode("ascii"), ffi.NULL)
 
 
 def test_empty_blobdir(tmpdir):
-    db_fname = tmpdir.join("hello.db")
     # Apparently some client code expects this to be the same as passing NULL.
     ctx = ffi.gc(
-        lib.dc_context_new(ffi.NULL, db_fname.strpath.encode("ascii"), b""),
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
         lib.dc_context_unref,
     )
-    assert ctx != ffi.NULL
+    db_fname = tmpdir.join("hello.db")
+    assert lib.dc_open(ctx, db_fname.strpath.encode("ascii"), b"")
 
 
 def test_event_defines():
@@ -55,20 +78,17 @@ def test_event_defines():
 
 
 def test_sig():
-    sig = capi.lib.dc_event_has_string_data
-    assert not sig(const.DC_EVENT_MSGS_CHANGED)
-    assert sig(const.DC_EVENT_INFO)
-    assert sig(const.DC_EVENT_WARNING)
-    assert sig(const.DC_EVENT_ERROR)
-    assert sig(const.DC_EVENT_SMTP_CONNECTED)
-    assert sig(const.DC_EVENT_IMAP_CONNECTED)
-    assert sig(const.DC_EVENT_SMTP_MESSAGE_SENT)
-    assert sig(const.DC_EVENT_IMEX_FILE_WRITTEN)
+    sig = capi.lib.dc_get_event_signature_types
+    assert sig(const.DC_EVENT_INFO) == 2
+    assert sig(const.DC_EVENT_WARNING) == 2
+    assert sig(const.DC_EVENT_ERROR) == 2
+    assert sig(const.DC_EVENT_SMTP_CONNECTED) == 2
+    assert sig(const.DC_EVENT_IMAP_CONNECTED) == 2
+    assert sig(const.DC_EVENT_SMTP_MESSAGE_SENT) == 2
 
 
 def test_markseen_invalid_message_ids(acfactory):
     ac1 = acfactory.get_configured_offline_account()
-
     contact1 = ac1.create_contact(email="some1@example.com", name="some1")
     chat = ac1.create_chat_by_contact(contact1)
     chat.send_text("one messae")
@@ -87,18 +107,47 @@ def test_get_special_message_id_returns_empty_message(acfactory):
 
 def test_provider_info_none():
     ctx = ffi.gc(
-        lib.dc_context_new(ffi.NULL, ffi.NULL, ffi.NULL),
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
         lib.dc_context_unref,
     )
     assert lib.dc_provider_new_from_email(ctx, cutil.as_dc_charpointer("email@unexistent.no")) == ffi.NULL
 
 
-def test_get_info_open(tmpdir):
-    db_fname = tmpdir.join("test.db")
+def test_get_info_closed():
     ctx = ffi.gc(
-        lib.dc_context_new(ffi.NULL, db_fname.strpath.encode("ascii"), ffi.NULL),
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
         lib.dc_context_unref,
     )
     info = cutil.from_dc_charpointer(lib.dc_get_info(ctx))
     assert 'deltachat_core_version' in info
+    assert 'database_dir' not in info
+
+
+def test_get_info_open(tmpdir):
+    ctx = ffi.gc(
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
+        lib.dc_context_unref,
+    )
+    db_fname = tmpdir.join("test.db")
+    lib.dc_open(ctx, db_fname.strpath.encode("ascii"), ffi.NULL)
+    info = cutil.from_dc_charpointer(lib.dc_get_info(ctx))
+    assert 'deltachat_core_version' in info
     assert 'database_dir' in info
+
+
+def test_is_open_closed():
+    ctx = ffi.gc(
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
+        lib.dc_context_unref,
+    )
+    assert lib.dc_is_open(ctx) == 0
+
+
+def test_is_open_actually_open(tmpdir):
+    ctx = ffi.gc(
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
+        lib.dc_context_unref,
+    )
+    db_fname = tmpdir.join("test.db")
+    lib.dc_open(ctx, db_fname.strpath.encode("ascii"), ffi.NULL)
+    assert lib.dc_is_open(ctx) == 1

rust-toolchain

@@ -1 +1 @@
-1.43.1
+nightly-2020-03-12

src/blob.rs

@@ -2,10 +2,9 @@
 
 use std::ffi::OsStr;
 use std::fmt;
-
-use async_std::path::{Path, PathBuf};
-use async_std::prelude::*;
-use async_std::{fs, io};
+use std::fs;
+use std::io::Write;
+use std::path::{Path, PathBuf};
 
 use image::GenericImageView;
 use thiserror::Error;
@@ -44,16 +43,15 @@ impl<'a> BlobObject<'a> {
     /// [BlobError::WriteFailure] is used when the file could not
     /// be written to.  You can expect [BlobError.cause] to contain an
     /// underlying error.
-    pub async fn create(
+    pub fn create(
         context: &'a Context,
         suggested_name: impl AsRef<str>,
         data: &[u8],
     ) -> std::result::Result<BlobObject<'a>, BlobError> {
         let blobdir = context.get_blobdir();
         let (stem, ext) = BlobObject::sanitise_name(suggested_name.as_ref());
-        let (name, mut file) = BlobObject::create_new_file(&blobdir, &stem, &ext).await?;
+        let (name, mut file) = BlobObject::create_new_file(&blobdir, &stem, &ext)?;
         file.write_all(data)
-            .await
             .map_err(|err| BlobError::WriteFailure {
                 blobdir: blobdir.to_path_buf(),
                 blobname: name.clone(),
@@ -63,16 +61,12 @@ impl<'a> BlobObject<'a> {
             blobdir,
             name: format!("$BLOBDIR/{}", name),
         };
-        context.emit_event(Event::NewBlobFile(blob.as_name().to_string()));
+        context.call_cb(Event::NewBlobFile(blob.as_name().to_string()));
         Ok(blob)
     }
 
     // Creates a new file, returning a tuple of the name and the handle.
-    async fn create_new_file(
-        dir: &Path,
-        stem: &str,
-        ext: &str,
-    ) -> Result<(String, fs::File), BlobError> {
+    fn create_new_file(dir: &Path, stem: &str, ext: &str) -> Result<(String, fs::File), BlobError> {
         let max_attempt = 15;
         let mut name = format!("{}{}", stem, ext);
         for attempt in 0..max_attempt {
@@ -81,7 +75,6 @@ impl<'a> BlobObject<'a> {
                 .create_new(true)
                 .write(true)
                 .open(&path)
-                .await
             {
                 Ok(file) => return Ok((name, file)),
                 Err(err) => {
@@ -117,41 +110,37 @@ impl<'a> BlobObject<'a> {
     /// In addition to the errors in [BlobObject::create] the
     /// [BlobError::CopyFailure] is used when the data can not be
     /// copied.
-    pub async fn create_and_copy(
+    pub fn create_and_copy(
         context: &'a Context,
         src: impl AsRef<Path>,
     ) -> std::result::Result<BlobObject<'a>, BlobError> {
-        let mut src_file =
-            fs::File::open(src.as_ref())
-                .await
-                .map_err(|err| BlobError::CopyFailure {
-                    blobdir: context.get_blobdir().to_path_buf(),
-                    blobname: String::from(""),
-                    src: src.as_ref().to_path_buf(),
-                    cause: err,
-                })?;
+        let mut src_file = fs::File::open(src.as_ref()).map_err(|err| BlobError::CopyFailure {
+            blobdir: context.get_blobdir().to_path_buf(),
+            blobname: String::from(""),
+            src: src.as_ref().to_path_buf(),
+            cause: err,
+        })?;
         let (stem, ext) = BlobObject::sanitise_name(&src.as_ref().to_string_lossy());
-        let (name, mut dst_file) =
-            BlobObject::create_new_file(context.get_blobdir(), &stem, &ext).await?;
+        let (name, mut dst_file) = BlobObject::create_new_file(context.get_blobdir(), &stem, &ext)?;
         let name_for_err = name.clone();
-        if let Err(err) = io::copy(&mut src_file, &mut dst_file).await {
+        std::io::copy(&mut src_file, &mut dst_file).map_err(|err| {
             {
                 // Attempt to remove the failed file, swallow errors resulting from that.
                 let path = context.get_blobdir().join(&name_for_err);
-                fs::remove_file(path).await.ok();
+                fs::remove_file(path).ok();
             }
-            return Err(BlobError::CopyFailure {
+            BlobError::CopyFailure {
                 blobdir: context.get_blobdir().to_path_buf(),
                 blobname: name_for_err,
                 src: src.as_ref().to_path_buf(),
                 cause: err,
-            });
-        }
+            }
+        })?;
         let blob = BlobObject {
             blobdir: context.get_blobdir(),
             name: format!("$BLOBDIR/{}", name),
         };
-        context.emit_event(Event::NewBlobFile(blob.as_name().to_string()));
+        context.call_cb(Event::NewBlobFile(blob.as_name().to_string()));
         Ok(blob)
     }
 
@@ -169,14 +158,14 @@ impl<'a> BlobObject<'a> {
     /// This merely delegates to the [BlobObject::create_and_copy] and
     /// the [BlobObject::from_path] methods.  See those for possible
     /// errors.
-    pub async fn new_from_path(
+    pub fn new_from_path(
         context: &Context,
         src: impl AsRef<Path>,
-    ) -> std::result::Result<BlobObject<'_>, BlobError> {
+    ) -> std::result::Result<BlobObject, BlobError> {
         if src.as_ref().starts_with(context.get_blobdir()) {
             BlobObject::from_path(context, src)
         } else {
-            BlobObject::create_and_copy(context, src).await
+            BlobObject::create_and_copy(context, src)
         }
     }
 
@@ -429,71 +418,58 @@ mod tests {
 
     use crate::test_utils::*;
 
-    #[async_std::test]
-    async fn test_create() {
-        let t = dummy_context().await;
-        let blob = BlobObject::create(&t.ctx, "foo", b"hello").await.unwrap();
+    #[test]
+    fn test_create() {
+        let t = dummy_context();
+        let blob = BlobObject::create(&t.ctx, "foo", b"hello").unwrap();
         let fname = t.ctx.get_blobdir().join("foo");
-        let data = fs::read(fname).await.unwrap();
+        let data = fs::read(fname).unwrap();
         assert_eq!(data, b"hello");
         assert_eq!(blob.as_name(), "$BLOBDIR/foo");
         assert_eq!(blob.to_abs_path(), t.ctx.get_blobdir().join("foo"));
     }
 
-    #[async_std::test]
-    async fn test_lowercase_ext() {
-        let t = dummy_context().await;
-        let blob = BlobObject::create(&t.ctx, "foo.TXT", b"hello")
-            .await
-            .unwrap();
+    #[test]
+    fn test_lowercase_ext() {
+        let t = dummy_context();
+        let blob = BlobObject::create(&t.ctx, "foo.TXT", b"hello").unwrap();
         assert_eq!(blob.as_name(), "$BLOBDIR/foo.txt");
     }
 
-    #[async_std::test]
-    async fn test_as_file_name() {
-        let t = dummy_context().await;
-        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello")
-            .await
-            .unwrap();
+    #[test]
+    fn test_as_file_name() {
+        let t = dummy_context();
+        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello").unwrap();
         assert_eq!(blob.as_file_name(), "foo.txt");
     }
 
-    #[async_std::test]
-    async fn test_as_rel_path() {
-        let t = dummy_context().await;
-        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello")
-            .await
-            .unwrap();
+    #[test]
+    fn test_as_rel_path() {
+        let t = dummy_context();
+        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello").unwrap();
         assert_eq!(blob.as_rel_path(), Path::new("foo.txt"));
     }
 
-    #[async_std::test]
-    async fn test_suffix() {
-        let t = dummy_context().await;
-        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello")
-            .await
-            .unwrap();
+    #[test]
+    fn test_suffix() {
+        let t = dummy_context();
+        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello").unwrap();
         assert_eq!(blob.suffix(), Some("txt"));
-        let blob = BlobObject::create(&t.ctx, "bar", b"world").await.unwrap();
+        let blob = BlobObject::create(&t.ctx, "bar", b"world").unwrap();
         assert_eq!(blob.suffix(), None);
     }
 
-    #[async_std::test]
-    async fn test_create_dup() {
-        let t = dummy_context().await;
-        BlobObject::create(&t.ctx, "foo.txt", b"hello")
-            .await
-            .unwrap();
+    #[test]
+    fn test_create_dup() {
+        let t = dummy_context();
+        BlobObject::create(&t.ctx, "foo.txt", b"hello").unwrap();
         let foo_path = t.ctx.get_blobdir().join("foo.txt");
-        assert!(foo_path.exists().await);
-        BlobObject::create(&t.ctx, "foo.txt", b"world")
-            .await
-            .unwrap();
-        let mut dir = fs::read_dir(t.ctx.get_blobdir()).await.unwrap();
-        while let Some(dirent) = dir.next().await {
+        assert!(foo_path.exists());
+        BlobObject::create(&t.ctx, "foo.txt", b"world").unwrap();
+        for dirent in fs::read_dir(t.ctx.get_blobdir()).unwrap() {
             let fname = dirent.unwrap().file_name();
             if fname == foo_path.file_name().unwrap() {
-                assert_eq!(fs::read(&foo_path).await.unwrap(), b"hello");
+                assert_eq!(fs::read(&foo_path).unwrap(), b"hello");
             } else {
                 let name = fname.to_str().unwrap();
                 assert!(name.starts_with("foo"));
@@ -502,22 +478,17 @@ mod tests {
         }
     }
 
-    #[async_std::test]
-    async fn test_double_ext_preserved() {
-        let t = dummy_context().await;
-        BlobObject::create(&t.ctx, "foo.tar.gz", b"hello")
-            .await
-            .unwrap();
+    #[test]
+    fn test_double_ext_preserved() {
+        let t = dummy_context();
+        BlobObject::create(&t.ctx, "foo.tar.gz", b"hello").unwrap();
         let foo_path = t.ctx.get_blobdir().join("foo.tar.gz");
-        assert!(foo_path.exists().await);
-        BlobObject::create(&t.ctx, "foo.tar.gz", b"world")
-            .await
-            .unwrap();
-        let mut dir = fs::read_dir(t.ctx.get_blobdir()).await.unwrap();
-        while let Some(dirent) = dir.next().await {
+        assert!(foo_path.exists());
+        BlobObject::create(&t.ctx, "foo.tar.gz", b"world").unwrap();
+        for dirent in fs::read_dir(t.ctx.get_blobdir()).unwrap() {
             let fname = dirent.unwrap().file_name();
             if fname == foo_path.file_name().unwrap() {
-                assert_eq!(fs::read(&foo_path).await.unwrap(), b"hello");
+                assert_eq!(fs::read(&foo_path).unwrap(), b"hello");
             } else {
                 let name = fname.to_str().unwrap();
                 println!("{}", name);
@@ -527,55 +498,55 @@ mod tests {
         }
     }
 
-    #[async_std::test]
-    async fn test_create_long_names() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_create_long_names() {
+        let t = dummy_context();
         let s = "1".repeat(150);
-        let blob = BlobObject::create(&t.ctx, &s, b"data").await.unwrap();
+        let blob = BlobObject::create(&t.ctx, &s, b"data").unwrap();
         let blobname = blob.as_name().split('/').last().unwrap();
         assert!(blobname.len() < 128);
     }
 
-    #[async_std::test]
-    async fn test_create_and_copy() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_create_and_copy() {
+        let t = dummy_context();
         let src = t.dir.path().join("src");
-        fs::write(&src, b"boo").await.unwrap();
-        let blob = BlobObject::create_and_copy(&t.ctx, &src).await.unwrap();
+        fs::write(&src, b"boo").unwrap();
+        let blob = BlobObject::create_and_copy(&t.ctx, &src).unwrap();
         assert_eq!(blob.as_name(), "$BLOBDIR/src");
-        let data = fs::read(blob.to_abs_path()).await.unwrap();
+        let data = fs::read(blob.to_abs_path()).unwrap();
         assert_eq!(data, b"boo");
 
         let whoops = t.dir.path().join("whoops");
-        assert!(BlobObject::create_and_copy(&t.ctx, &whoops).await.is_err());
+        assert!(BlobObject::create_and_copy(&t.ctx, &whoops).is_err());
         let whoops = t.ctx.get_blobdir().join("whoops");
-        assert!(!whoops.exists().await);
+        assert!(!whoops.exists());
     }
 
-    #[async_std::test]
-    async fn test_create_from_path() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_create_from_path() {
+        let t = dummy_context();
 
         let src_ext = t.dir.path().join("external");
-        fs::write(&src_ext, b"boo").await.unwrap();
-        let blob = BlobObject::new_from_path(&t.ctx, &src_ext).await.unwrap();
+        fs::write(&src_ext, b"boo").unwrap();
+        let blob = BlobObject::new_from_path(&t.ctx, &src_ext).unwrap();
         assert_eq!(blob.as_name(), "$BLOBDIR/external");
-        let data = fs::read(blob.to_abs_path()).await.unwrap();
+        let data = fs::read(blob.to_abs_path()).unwrap();
         assert_eq!(data, b"boo");
 
         let src_int = t.ctx.get_blobdir().join("internal");
-        fs::write(&src_int, b"boo").await.unwrap();
-        let blob = BlobObject::new_from_path(&t.ctx, &src_int).await.unwrap();
+        fs::write(&src_int, b"boo").unwrap();
+        let blob = BlobObject::new_from_path(&t.ctx, &src_int).unwrap();
         assert_eq!(blob.as_name(), "$BLOBDIR/internal");
-        let data = fs::read(blob.to_abs_path()).await.unwrap();
+        let data = fs::read(blob.to_abs_path()).unwrap();
         assert_eq!(data, b"boo");
     }
-    #[async_std::test]
-    async fn test_create_from_name_long() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_create_from_name_long() {
+        let t = dummy_context();
         let src_ext = t.dir.path().join("autocrypt-setup-message-4137848473.html");
-        fs::write(&src_ext, b"boo").await.unwrap();
-        let blob = BlobObject::new_from_path(&t.ctx, &src_ext).await.unwrap();
+        fs::write(&src_ext, b"boo").unwrap();
+        let blob = BlobObject::new_from_path(&t.ctx, &src_ext).unwrap();
         assert_eq!(
             blob.as_name(),
             "$BLOBDIR/autocrypt-setup-message-4137848473.html"

src/chatlist.rs

@@ -86,7 +86,7 @@ impl Chatlist {
     ///     are returned.
     /// `query_contact_id`: An optional contact ID for filtering the list. Only chats including this contact ID
     ///     are returned.
-    pub async fn try_load(
+    pub fn try_load(
         context: &Context,
         listflags: usize,
         query: Option<&str>,
@@ -99,7 +99,7 @@ impl Chatlist {
 
         // Note that we do not emit DC_EVENT_MSGS_MODIFIED here even if some
         // messages get deleted to avoid reloading the same chatlist.
-        if let Err(err) = delete_device_expired_messages(context).await {
+        if let Err(err) = delete_device_expired_messages(context) {
             warn!(context, "Failed to hide expired messages: {}", err);
         }
 
@@ -118,7 +118,6 @@ impl Chatlist {
 
         let skip_id = if flag_for_forwarding {
             chat::lookup_by_contact_id(context, DC_CONTACT_ID_DEVICE)
-                .await
                 .unwrap_or_default()
                 .0
         } else {
@@ -157,19 +156,17 @@ impl Chatlist {
                    AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?2)
                  GROUP BY c.id
                  ORDER BY c.archived=?3 DESC, IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                paramsv![MessageState::OutDraft, query_contact_id as i32, ChatVisibility::Pinned],
+                params![MessageState::OutDraft, query_contact_id as i32, ChatVisibility::Pinned],
                 process_row,
                 process_rows,
-            ).await?
+            )?
         } else if flag_archived_only {
             // show archived chats
             // (this includes the archived device-chat; we could skip it,
             // however, then the number of archived chats do not match, which might be even more irritating.
             // and adapting the number requires larger refactorings and seems not to be worth the effort)
-            context
-                .sql
-                .query_map(
-                    "SELECT c.id, m.id
+            context.sql.query_map(
+                "SELECT c.id, m.id
                  FROM chats c
                  LEFT JOIN msgs m
                         ON c.id=m.chat_id
@@ -183,26 +180,23 @@ impl Chatlist {
                    AND c.archived=1
                  GROUP BY c.id
                  ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                    paramsv![MessageState::OutDraft],
-                    process_row,
-                    process_rows,
-                )
-                .await?
+                params![MessageState::OutDraft],
+                process_row,
+                process_rows,
+            )?
         } else if let Some(query) = query {
             let query = query.trim().to_string();
             ensure!(!query.is_empty(), "missing query");
 
             // allow searching over special names that may change at any time
             // when the ui calls set_stock_translation()
-            if let Err(err) = update_special_chat_names(context).await {
+            if let Err(err) = update_special_chat_names(context) {
                 warn!(context, "cannot update special chat names: {:?}", err)
             }
 
             let str_like_cmd = format!("%{}%", query);
-            context
-                .sql
-                .query_map(
-                    "SELECT c.id, m.id
+            context.sql.query_map(
+                "SELECT c.id, m.id
                  FROM chats c
                  LEFT JOIN msgs m
                         ON c.id=m.chat_id
@@ -216,16 +210,14 @@ impl Chatlist {
                    AND c.name LIKE ?3
                  GROUP BY c.id
                  ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                    paramsv![MessageState::OutDraft, skip_id, str_like_cmd],
-                    process_row,
-                    process_rows,
-                )
-                .await?
+                params![MessageState::OutDraft, skip_id, str_like_cmd],
+                process_row,
+                process_rows,
+            )?
         } else {
             //  show normal chatlist
             let sort_id_up = if flag_for_forwarding {
                 chat::lookup_by_contact_id(context, DC_CONTACT_ID_SELF)
-                    .await
                     .unwrap_or_default()
                     .0
             } else {
@@ -246,13 +238,12 @@ impl Chatlist {
                    AND NOT c.archived=?3
                  GROUP BY c.id
                  ORDER BY c.id=?4 DESC, c.archived=?5 DESC, IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
-                paramsv![MessageState::OutDraft, skip_id, ChatVisibility::Archived, sort_id_up, ChatVisibility::Pinned],
+                params![MessageState::OutDraft, skip_id, ChatVisibility::Archived, sort_id_up, ChatVisibility::Pinned],
                 process_row,
                 process_rows,
-            ).await?;
+            )?;
             if !flag_no_specials {
-                if let Some(last_deaddrop_fresh_msg_id) = get_last_deaddrop_fresh_msg(context).await
-                {
+                if let Some(last_deaddrop_fresh_msg_id) = get_last_deaddrop_fresh_msg(context) {
                     if !flag_for_forwarding {
                         ids.insert(
                             0,
@@ -265,7 +256,7 @@ impl Chatlist {
             ids
         };
 
-        if add_archived_link_item && dc_get_archived_cnt(context).await > 0 {
+        if add_archived_link_item && dc_get_archived_cnt(context) > 0 {
             if ids.is_empty() && flag_add_alldone_hint {
                 ids.push((ChatId::new(DC_CHAT_ID_ALLDONE_HINT), MsgId::new(0)));
             }
@@ -319,7 +310,7 @@ impl Chatlist {
     /// - dc_lot_t::timestamp: the timestamp of the message.  0 if not applicable.
     /// - dc_lot_t::state: The state of the message as one of the DC_STATE_* constants (see #dc_msg_get_state()).
     //    0 if not applicable.
-    pub async fn get_summary(&self, context: &Context, index: usize, chat: Option<&Chat>) -> Lot {
+    pub fn get_summary(&self, context: &Context, index: usize, chat: Option<&Chat>) -> Lot {
         // The summary is created by the chat, not by the last message.
         // This is because we may want to display drafts here or stuff as
         // "is typing".
@@ -337,7 +328,7 @@ impl Chatlist {
         let chat_loaded: Chat;
         let chat = if let Some(chat) = chat {
             chat
-        } else if let Ok(chat) = Chat::load_from_db(context, *chat_id).await {
+        } else if let Ok(chat) = Chat::load_from_db(context, *chat_id) {
             chat_loaded = chat;
             &chat_loaded
         } else {
@@ -346,11 +337,11 @@ impl Chatlist {
 
         let mut lastcontact = None;
 
-        let lastmsg = if let Ok(lastmsg) = Message::load_from_db(context, *lastmsg_id).await {
+        let lastmsg = if let Ok(lastmsg) = Message::load_from_db(context, *lastmsg_id) {
             if lastmsg.from_id != DC_CONTACT_ID_SELF
                 && (chat.typ == Chattype::Group || chat.typ == Chattype::VerifiedGroup)
             {
-                lastcontact = Contact::load_from_db(context, lastmsg.from_id).await.ok();
+                lastcontact = Contact::load_from_db(context, lastmsg.from_id).ok();
             }
 
             Some(lastmsg)
@@ -362,15 +353,9 @@ impl Chatlist {
             ret.text2 = None;
         } else if lastmsg.is_none() || lastmsg.as_ref().unwrap().from_id == DC_CONTACT_ID_UNDEFINED
         {
-            ret.text2 = Some(
-                context
-                    .stock_str(StockMessage::NoMessages)
-                    .await
-                    .to_string(),
-            );
+            ret.text2 = Some(context.stock_str(StockMessage::NoMessages).to_string());
         } else {
-            ret.fill(&mut lastmsg.unwrap(), chat, lastcontact.as_ref(), context)
-                .await;
+            ret.fill(&mut lastmsg.unwrap(), chat, lastcontact.as_ref(), context);
         }
 
         ret
@@ -382,38 +367,34 @@ impl Chatlist {
 }
 
 /// Returns the number of archived chats
-pub async fn dc_get_archived_cnt(context: &Context) -> u32 {
+pub fn dc_get_archived_cnt(context: &Context) -> u32 {
     context
         .sql
         .query_get_value(
             context,
             "SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;",
-            paramsv![],
+            params![],
         )
-        .await
         .unwrap_or_default()
 }
 
-async fn get_last_deaddrop_fresh_msg(context: &Context) -> Option<MsgId> {
+fn get_last_deaddrop_fresh_msg(context: &Context) -> Option<MsgId> {
     // We have an index over the state-column, this should be
     // sufficient as there are typically only few fresh messages.
-    context
-        .sql
-        .query_get_value(
-            context,
-            concat!(
-                "SELECT m.id",
-                " FROM msgs m",
-                " LEFT JOIN chats c",
-                "        ON c.id=m.chat_id",
-                " WHERE m.state=10",
-                "   AND m.hidden=0",
-                "   AND c.blocked=2",
-                " ORDER BY m.timestamp DESC, m.id DESC;"
-            ),
-            paramsv![],
-        )
-        .await
+    context.sql.query_get_value(
+        context,
+        concat!(
+            "SELECT m.id",
+            " FROM msgs m",
+            " LEFT JOIN chats c",
+            "        ON c.id=m.chat_id",
+            " WHERE m.state=10",
+            "   AND m.hidden=0",
+            "   AND c.blocked=2",
+            " ORDER BY m.timestamp DESC, m.id DESC;"
+        ),
+        params![],
+    )
 }
 
 #[cfg(test)]
@@ -422,21 +403,15 @@ mod tests {
 
     use crate::test_utils::*;
 
-    #[async_std::test]
-    async fn test_try_load() {
-        let t = dummy_context().await;
-        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat")
-            .await
-            .unwrap();
-        let chat_id2 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "b chat")
-            .await
-            .unwrap();
-        let chat_id3 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "c chat")
-            .await
-            .unwrap();
+    #[test]
+    fn test_try_load() {
+        let t = dummy_context();
+        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat").unwrap();
+        let chat_id2 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "b chat").unwrap();
+        let chat_id3 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "c chat").unwrap();
 
         // check that the chatlist starts with the most recent message
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
         assert_eq!(chats.len(), 3);
         assert_eq!(chats.get_chat_id(0), chat_id3);
         assert_eq!(chats.get_chat_id(1), chat_id2);
@@ -445,102 +420,77 @@ mod tests {
         // drafts are sorted to the top
         let mut msg = Message::new(Viewtype::Text);
         msg.set_text(Some("hello".to_string()));
-        chat_id2.set_draft(&t.ctx, Some(&mut msg)).await;
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
+        chat_id2.set_draft(&t.ctx, Some(&mut msg));
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
         assert_eq!(chats.get_chat_id(0), chat_id2);
 
         // check chatlist query and archive functionality
-        let chats = Chatlist::try_load(&t.ctx, 0, Some("b"), None)
-            .await
-            .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, 0, Some("b"), None).unwrap();
         assert_eq!(chats.len(), 1);
 
-        let chats = Chatlist::try_load(&t.ctx, DC_GCL_ARCHIVED_ONLY, None, None)
-            .await
-            .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, DC_GCL_ARCHIVED_ONLY, None, None).unwrap();
         assert_eq!(chats.len(), 0);
 
         chat_id1
             .set_visibility(&t.ctx, ChatVisibility::Archived)
-            .await
             .ok();
-        let chats = Chatlist::try_load(&t.ctx, DC_GCL_ARCHIVED_ONLY, None, None)
-            .await
-            .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, DC_GCL_ARCHIVED_ONLY, None, None).unwrap();
         assert_eq!(chats.len(), 1);
     }
 
-    #[async_std::test]
-    async fn test_sort_self_talk_up_on_forward() {
-        let t = dummy_context().await;
-        t.ctx.update_device_chats().await.unwrap();
-        create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat")
-            .await
-            .unwrap();
+    #[test]
+    fn test_sort_self_talk_up_on_forward() {
+        let t = dummy_context();
+        t.ctx.update_device_chats().unwrap();
+        create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat").unwrap();
 
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
         assert!(chats.len() == 3);
         assert!(!Chat::load_from_db(&t.ctx, chats.get_chat_id(0))
-            .await
             .unwrap()
             .is_self_talk());
 
-        let chats = Chatlist::try_load(&t.ctx, DC_GCL_FOR_FORWARDING, None, None)
-            .await
-            .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, DC_GCL_FOR_FORWARDING, None, None).unwrap();
         assert!(chats.len() == 2); // device chat cannot be written and is skipped on forwarding
         assert!(Chat::load_from_db(&t.ctx, chats.get_chat_id(0))
-            .await
             .unwrap()
             .is_self_talk());
     }
 
-    #[async_std::test]
-    async fn test_search_special_chat_names() {
-        let t = dummy_context().await;
-        t.ctx.update_device_chats().await.unwrap();
+    #[test]
+    fn test_search_special_chat_names() {
+        let t = dummy_context();
+        t.ctx.update_device_chats().unwrap();
 
-        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-1234-s"), None)
-            .await
-            .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-1234-s"), None).unwrap();
         assert_eq!(chats.len(), 0);
-        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-5678-b"), None)
-            .await
-            .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-5678-b"), None).unwrap();
         assert_eq!(chats.len(), 0);
 
         t.ctx
             .set_stock_translation(StockMessage::SavedMessages, "test-1234-save".to_string())
-            .await
-            .unwrap();
-        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-1234-s"), None)
-            .await
             .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-1234-s"), None).unwrap();
         assert_eq!(chats.len(), 1);
 
         t.ctx
             .set_stock_translation(StockMessage::DeviceMessages, "test-5678-babbel".to_string())
-            .await
-            .unwrap();
-        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-5678-b"), None)
-            .await
             .unwrap();
+        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-5678-b"), None).unwrap();
         assert_eq!(chats.len(), 1);
     }
 
-    #[async_std::test]
-    async fn test_get_summary_unwrap() {
-        let t = dummy_context().await;
-        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat")
-            .await
-            .unwrap();
+    #[test]
+    fn test_get_summary_unwrap() {
+        let t = dummy_context();
+        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat").unwrap();
 
         let mut msg = Message::new(Viewtype::Text);
         msg.set_text(Some("foo:\nbar \r\n test".to_string()));
-        chat_id1.set_draft(&t.ctx, Some(&mut msg)).await;
+        chat_id1.set_draft(&t.ctx, Some(&mut msg));
 
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
-        let summary = chats.get_summary(&t.ctx, 0, None).await;
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
+        let summary = chats.get_summary(&t.ctx, 0, None);
         assert_eq!(summary.get_text2().unwrap(), "foo: bar test"); // the linebreak should be removed from summary
     }
 }

src/config.rs

@@ -9,9 +9,11 @@ use crate::constants::DC_VERSION_STR;
 use crate::context::Context;
 use crate::dc_tools::*;
 use crate::events::Event;
+use crate::job::*;
 use crate::message::MsgId;
 use crate::mimefactory::RECOMMENDED_FILE_SIZE;
 use crate::stock::StockMessage;
+use rusqlite::NO_PARAMS;
 
 /// The available configuration keys.
 #[derive(
@@ -118,16 +120,16 @@ pub enum Config {
 
 impl Context {
     /// Get a configuration key. Returns `None` if no value is set, and no default value found.
-    pub async fn get_config(&self, key: Config) -> Option<String> {
+    pub fn get_config(&self, key: Config) -> Option<String> {
         let value = match key {
             Config::Selfavatar => {
-                let rel_path = self.sql.get_raw_config(self, key).await;
+                let rel_path = self.sql.get_raw_config(self, key);
                 rel_path.map(|p| dc_get_abs_path(self, &p).to_string_lossy().into_owned())
             }
             Config::SysVersion => Some((&*DC_VERSION_STR).clone()),
             Config::SysMsgsizeMaxRecommended => Some(format!("{}", RECOMMENDED_FILE_SIZE)),
             Config::SysConfigKeys => Some(get_config_keys_string()),
-            _ => self.sql.get_raw_config(self, key).await,
+            _ => self.sql.get_raw_config(self, key),
         };
 
         if value.is_some() {
@@ -136,28 +138,27 @@ impl Context {
 
         // Default values
         match key {
-            Config::Selfstatus => Some(self.stock_str(StockMessage::StatusLine).await.into_owned()),
+            Config::Selfstatus => Some(self.stock_str(StockMessage::StatusLine).into_owned()),
             _ => key.get_str("default").map(|s| s.to_string()),
         }
     }
 
-    pub async fn get_config_int(&self, key: Config) -> i32 {
+    pub fn get_config_int(&self, key: Config) -> i32 {
         self.get_config(key)
-            .await
             .and_then(|s| s.parse().ok())
             .unwrap_or_default()
     }
 
-    pub async fn get_config_bool(&self, key: Config) -> bool {
-        self.get_config_int(key).await != 0
+    pub fn get_config_bool(&self, key: Config) -> bool {
+        self.get_config_int(key) != 0
     }
 
     /// Gets configured "delete_server_after" value.
     ///
     /// `None` means never delete the message, `Some(0)` means delete
     /// at once, `Some(x)` means delete after `x` seconds.
-    pub async fn get_config_delete_server_after(&self) -> Option<i64> {
-        match self.get_config_int(Config::DeleteServerAfter).await {
+    pub fn get_config_delete_server_after(&self) -> Option<i64> {
+        match self.get_config_int(Config::DeleteServerAfter) {
             0 => None,
             1 => Some(0),
             x => Some(x as i64),
@@ -168,8 +169,8 @@ impl Context {
     ///
     /// `None` means never delete the message, `Some(x)` means delete
     /// after `x` seconds.
-    pub async fn get_config_delete_device_after(&self) -> Option<i64> {
-        match self.get_config_int(Config::DeleteDeviceAfter).await {
+    pub fn get_config_delete_device_after(&self) -> Option<i64> {
+        match self.get_config_int(Config::DeleteDeviceAfter) {
             0 => None,
             x => Some(x as i64),
         }
@@ -177,61 +178,57 @@ impl Context {
 
     /// Set the given config key.
     /// If `None` is passed as a value the value is cleared and set to the default if there is one.
-    pub async fn set_config(&self, key: Config, value: Option<&str>) -> crate::sql::Result<()> {
+    pub fn set_config(&self, key: Config, value: Option<&str>) -> crate::sql::Result<()> {
         match key {
             Config::Selfavatar => {
                 self.sql
-                    .execute("UPDATE contacts SET selfavatar_sent=0;", paramsv![])
-                    .await?;
+                    .execute("UPDATE contacts SET selfavatar_sent=0;", NO_PARAMS)?;
                 self.sql
-                    .set_raw_config_bool(self, "attach_selfavatar", true)
-                    .await?;
+                    .set_raw_config_bool(self, "attach_selfavatar", true)?;
                 match value {
                     Some(value) => {
-                        let blob = BlobObject::new_from_path(&self, value).await?;
+                        let blob = BlobObject::new_from_path(&self, value)?;
                         blob.recode_to_avatar_size(self)?;
-                        self.sql
-                            .set_raw_config(self, key, Some(blob.as_name()))
-                            .await
+                        self.sql.set_raw_config(self, key, Some(blob.as_name()))
                     }
-                    None => self.sql.set_raw_config(self, key, None).await,
+                    None => self.sql.set_raw_config(self, key, None),
                 }
             }
             Config::InboxWatch => {
-                let ret = self.sql.set_raw_config(self, key, value).await;
-                self.interrupt_inbox(false).await;
+                let ret = self.sql.set_raw_config(self, key, value);
+                interrupt_inbox_idle(self);
                 ret
             }
             Config::SentboxWatch => {
-                let ret = self.sql.set_raw_config(self, key, value).await;
-                self.interrupt_sentbox(false).await;
+                let ret = self.sql.set_raw_config(self, key, value);
+                interrupt_sentbox_idle(self);
                 ret
             }
             Config::MvboxWatch => {
-                let ret = self.sql.set_raw_config(self, key, value).await;
-                self.interrupt_mvbox(false).await;
+                let ret = self.sql.set_raw_config(self, key, value);
+                interrupt_mvbox_idle(self);
                 ret
             }
             Config::Selfstatus => {
-                let def = self.stock_str(StockMessage::StatusLine).await;
+                let def = self.stock_str(StockMessage::StatusLine);
                 let val = if value.is_none() || value.unwrap() == def {
                     None
                 } else {
                     value
                 };
 
-                self.sql.set_raw_config(self, key, val).await
+                self.sql.set_raw_config(self, key, val)
             }
             Config::DeleteDeviceAfter => {
-                let ret = self.sql.set_raw_config(self, key, value).await;
+                let ret = self.sql.set_raw_config(self, key, value);
                 // Force chatlist reload to delete old messages immediately.
-                self.emit_event(Event::MsgsChanged {
+                self.call_cb(Event::MsgsChanged {
                     msg_id: MsgId::new(0),
                     chat_id: ChatId::new(0),
                 });
                 ret
             }
-            _ => self.sql.set_raw_config(self, key, value).await,
+            _ => self.sql.set_raw_config(self, key, value),
         }
     }
 }
@@ -279,9 +276,9 @@ mod tests {
         assert_eq!(Config::ImapFolder.get_str("default"), Some("INBOX"));
     }
 
-    #[async_std::test]
-    async fn test_selfavatar_outside_blobdir() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_selfavatar_outside_blobdir() {
+        let t = dummy_context();
         let avatar_src = t.dir.path().join("avatar.jpg");
         let avatar_bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
         File::create(&avatar_src)
@@ -289,14 +286,13 @@ mod tests {
             .write_all(avatar_bytes)
             .unwrap();
         let avatar_blob = t.ctx.get_blobdir().join("avatar.jpg");
-        assert!(!avatar_blob.exists().await);
+        assert!(!avatar_blob.exists());
         t.ctx
             .set_config(Config::Selfavatar, Some(&avatar_src.to_str().unwrap()))
-            .await
             .unwrap();
-        assert!(avatar_blob.exists().await);
+        assert!(avatar_blob.exists());
         assert!(std::fs::metadata(&avatar_blob).unwrap().len() < avatar_bytes.len() as u64);
-        let avatar_cfg = t.ctx.get_config(Config::Selfavatar).await;
+        let avatar_cfg = t.ctx.get_config(Config::Selfavatar);
         assert_eq!(avatar_cfg, avatar_blob.to_str().map(|s| s.to_string()));
 
         let img = image::open(avatar_src).unwrap();
@@ -308,9 +304,9 @@ mod tests {
         assert_eq!(img.height(), AVATAR_SIZE);
     }
 
-    #[async_std::test]
-    async fn test_selfavatar_in_blobdir() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_selfavatar_in_blobdir() {
+        let t = dummy_context();
         let avatar_src = t.ctx.get_blobdir().join("avatar.png");
         let avatar_bytes = include_bytes!("../test-data/image/avatar900x900.png");
         File::create(&avatar_src)
@@ -324,9 +320,8 @@ mod tests {
 
         t.ctx
             .set_config(Config::Selfavatar, Some(&avatar_src.to_str().unwrap()))
-            .await
             .unwrap();
-        let avatar_cfg = t.ctx.get_config(Config::Selfavatar).await;
+        let avatar_cfg = t.ctx.get_config(Config::Selfavatar);
         assert_eq!(avatar_cfg, avatar_src.to_str().map(|s| s.to_string()));
 
         let img = image::open(avatar_src).unwrap();
@@ -334,9 +329,9 @@ mod tests {
         assert_eq!(img.height(), AVATAR_SIZE);
     }
 
-    #[async_std::test]
-    async fn test_selfavatar_copy_without_recode() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_selfavatar_copy_without_recode() {
+        let t = dummy_context();
         let avatar_src = t.dir.path().join("avatar.png");
         let avatar_bytes = include_bytes!("../test-data/image/avatar64x64.png");
         File::create(&avatar_src)
@@ -344,34 +339,30 @@ mod tests {
             .write_all(avatar_bytes)
             .unwrap();
         let avatar_blob = t.ctx.get_blobdir().join("avatar.png");
-        assert!(!avatar_blob.exists().await);
+        assert!(!avatar_blob.exists());
         t.ctx
             .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(),
             avatar_bytes.len() as u64
         );
-        let avatar_cfg = t.ctx.get_config(Config::Selfavatar).await;
+        let avatar_cfg = t.ctx.get_config(Config::Selfavatar);
         assert_eq!(avatar_cfg, avatar_blob.to_str().map(|s| s.to_string()));
     }
 
-    #[async_std::test]
-    async fn test_media_quality_config_option() {
-        let t = dummy_context().await;
-        let media_quality = t.ctx.get_config_int(Config::MediaQuality).await;
+    #[test]
+    fn test_media_quality_config_option() {
+        let t = dummy_context();
+        let media_quality = t.ctx.get_config_int(Config::MediaQuality);
         assert_eq!(media_quality, 0);
         let media_quality = constants::MediaQuality::from_i32(media_quality).unwrap_or_default();
         assert_eq!(media_quality, constants::MediaQuality::Balanced);
 
-        t.ctx
-            .set_config(Config::MediaQuality, Some("1"))
-            .await
-            .unwrap();
+        t.ctx.set_config(Config::MediaQuality, Some("1")).unwrap();
 
-        let media_quality = t.ctx.get_config_int(Config::MediaQuality).await;
+        let media_quality = t.ctx.get_config_int(Config::MediaQuality);
         assert_eq!(media_quality, 1);
         assert_eq!(constants::MediaQuality::Worse as i32, 1);
         let media_quality = constants::MediaQuality::from_i32(media_quality).unwrap_or_default();

src/configure/auto_mozilla.rs

@@ -94,12 +94,12 @@ fn parse_xml(in_emailaddr: &str, xml_raw: &str) -> Result<LoginParam, Error> {
     }
 }
 
-pub async fn moz_autoconfigure(
+pub fn moz_autoconfigure(
     context: &Context,
     url: &str,
     param_in: &LoginParam,
 ) -> Result<LoginParam, Error> {
-    let xml_raw = read_url(context, url).await?;
+    let xml_raw = read_url(context, url)?;
 
     let res = parse_xml(&param_in.addr, &xml_raw);
     if let Err(err) = &res {

src/configure/auto_outlook.rs

@@ -112,7 +112,7 @@ fn parse_xml(xml_raw: &str) -> Result<ParsingResult, Error> {
     Ok(res)
 }
 
-pub async fn outlk_autodiscover(
+pub fn outlk_autodiscover(
     context: &Context,
     url: &str,
     _param_in: &LoginParam,
@@ -120,7 +120,7 @@ pub async fn outlk_autodiscover(
     let mut url = url.to_string();
     /* Follow up to 10 xml-redirects (http-redirects are followed in read_url() */
     for _i in 0..10 {
-        let xml_raw = read_url(context, &url).await?;
+        let xml_raw = read_url(context, &url)?;
         let res = parse_xml(&xml_raw);
         if let Err(err) = &res {
             warn!(context, "{}", err);

src/configure/read_url.rs

@@ -3,13 +3,17 @@ use crate::context::Context;
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("URL request error")]
-    GetError(surf::Error),
+    GetError(#[from] reqwest::Error),
 }
 
-pub async fn read_url(context: &Context, url: &str) -> Result<String, Error> {
+pub fn read_url(context: &Context, url: &str) -> Result<String, Error> {
     info!(context, "Requesting URL {}", url);
 
-    match surf::get(url).recv_string().await {
+    match reqwest::blocking::Client::new()
+        .get(url)
+        .send()
+        .and_then(|res| res.text())
+    {
         Ok(res) => Ok(res),
         Err(err) => {
             info!(context, "Can\'t read URL {}", url);

src/context.rs

@@ -2,10 +2,8 @@
 
 use std::collections::{BTreeMap, HashMap};
 use std::ffi::OsString;
-use std::ops::Deref;
-
-use async_std::path::{Path, PathBuf};
-use async_std::sync::{channel, Arc, Mutex, Receiver, RwLock, Sender};
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Condvar, Mutex, RwLock};
 
 use crate::chat::*;
 use crate::config::Config;
@@ -13,58 +11,61 @@ use crate::constants::*;
 use crate::contact::*;
 use crate::dc_tools::duration_to_str;
 use crate::error::*;
-use crate::events::{Event, EventEmitter, Events};
-use crate::job::{self, Action};
-use crate::key::{DcKey, SignedPublicKey};
+use crate::events::Event;
+use crate::imap::*;
+use crate::job::*;
+use crate::job_thread::JobThread;
+use crate::key::{DcKey, Key, SignedPublicKey};
 use crate::login_param::LoginParam;
 use crate::lot::Lot;
 use crate::message::{self, Message, MessengerMessage, MsgId};
 use crate::param::Params;
-use crate::scheduler::Scheduler;
+use crate::smtp::Smtp;
 use crate::sql::Sql;
 use std::time::SystemTime;
 
-#[derive(Clone, Debug)]
+/// Callback function type for [Context]
+///
+/// # Parameters
+///
+/// * `context` - The context object as returned by [Context::new].
+/// * `event` - One of the [Event] items.
+/// * `data1` - Depends on the event parameter, see [Event].
+/// * `data2` - Depends on the event parameter, see [Event].
+pub type ContextCallback = dyn Fn(&Context, Event) -> () + Send + Sync;
+
+#[derive(DebugStub)]
 pub struct Context {
-    pub(crate) inner: Arc<InnerContext>,
-}
-
-impl Deref for Context {
-    type Target = InnerContext;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-#[derive(Debug)]
-pub struct InnerContext {
     /// Database file path
-    pub(crate) dbfile: PathBuf,
+    dbfile: PathBuf,
     /// Blob directory path
-    pub(crate) blobdir: PathBuf,
-    pub(crate) sql: Sql,
-    pub(crate) os_name: Option<String>,
-    pub(crate) bob: RwLock<BobStatus>,
-    pub(crate) last_smeared_timestamp: RwLock<i64>,
-    pub(crate) running_state: RwLock<RunningState>,
+    blobdir: PathBuf,
+    pub sql: Sql,
+    pub perform_inbox_jobs_needed: Arc<RwLock<bool>>,
+    pub probe_imap_network: Arc<RwLock<bool>>,
+    pub inbox_thread: Arc<RwLock<JobThread>>,
+    pub sentbox_thread: Arc<RwLock<JobThread>>,
+    pub mvbox_thread: Arc<RwLock<JobThread>>,
+    pub smtp: Arc<Mutex<Smtp>>,
+    pub smtp_state: Arc<(Mutex<SmtpState>, Condvar)>,
+    pub oauth2_critical: Arc<Mutex<()>>,
+    #[debug_stub = "Callback"]
+    cb: Box<ContextCallback>,
+    pub os_name: Option<String>,
+    pub cmdline_sel_chat_id: Arc<RwLock<ChatId>>,
+    pub(crate) bob: Arc<RwLock<BobStatus>>,
+    pub last_smeared_timestamp: RwLock<i64>,
+    pub running_state: Arc<RwLock<RunningState>>,
     /// Mutex to avoid generating the key for the user more than once.
-    pub(crate) generating_key_mutex: Mutex<()>,
-    /// Mutex to enforce only a single running oauth2 is running.
-    pub(crate) oauth2_mutex: Mutex<()>,
-    pub(crate) translated_stockstrings: RwLock<HashMap<usize, String>>,
-    pub(crate) events: Events,
-
-    pub(crate) scheduler: RwLock<Scheduler>,
-
+    pub generating_key_mutex: Mutex<()>,
+    pub translated_stockstrings: RwLock<HashMap<usize, String>>,
     creation_time: SystemTime,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct RunningState {
     pub ongoing_running: bool,
     shall_stop_ongoing: bool,
-    cancel_sender: Option<Sender<()>>,
 }
 
 /// Return some info about deltachat-core
@@ -84,95 +85,73 @@ pub fn get_info() -> BTreeMap<&'static str, String> {
 
 impl Context {
     /// Creates new context.
-    pub async fn new(os_name: String, dbfile: PathBuf) -> Result<Context> {
-        // pretty_env_logger::try_init_timed().ok();
+    pub fn new(cb: Box<ContextCallback>, os_name: String, dbfile: PathBuf) -> Result<Context> {
+        pretty_env_logger::try_init_timed().ok();
 
         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() {
+            std::fs::create_dir_all(&blobdir)?;
         }
-        Context::with_blobdir(os_name, dbfile, blobdir).await
+        Context::with_blobdir(cb, os_name, dbfile, blobdir)
     }
 
-    pub async fn with_blobdir(
+    pub fn with_blobdir(
+        cb: Box<ContextCallback>,
         os_name: String,
         dbfile: PathBuf,
         blobdir: PathBuf,
     ) -> Result<Context> {
         ensure!(
-            blobdir.is_dir().await,
+            blobdir.is_dir(),
             "Blobdir does not exist: {}",
             blobdir.display()
         );
-
-        let inner = InnerContext {
+        let ctx = Context {
             blobdir,
             dbfile,
+            cb,
             os_name: Some(os_name),
-            running_state: RwLock::new(Default::default()),
+            running_state: Arc::new(RwLock::new(Default::default())),
             sql: Sql::new(),
-            bob: RwLock::new(Default::default()),
+            smtp: Arc::new(Mutex::new(Smtp::new())),
+            smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
+            oauth2_critical: Arc::new(Mutex::new(())),
+            bob: Arc::new(RwLock::new(Default::default())),
             last_smeared_timestamp: RwLock::new(0),
+            cmdline_sel_chat_id: Arc::new(RwLock::new(ChatId::new(0))),
+            inbox_thread: Arc::new(RwLock::new(JobThread::new(
+                "INBOX",
+                "configured_inbox_folder",
+                Imap::new(),
+            ))),
+            sentbox_thread: Arc::new(RwLock::new(JobThread::new(
+                "SENTBOX",
+                "configured_sentbox_folder",
+                Imap::new(),
+            ))),
+            mvbox_thread: Arc::new(RwLock::new(JobThread::new(
+                "MVBOX",
+                "configured_mvbox_folder",
+                Imap::new(),
+            ))),
+            probe_imap_network: Arc::new(RwLock::new(false)),
+            perform_inbox_jobs_needed: Arc::new(RwLock::new(false)),
             generating_key_mutex: Mutex::new(()),
-            oauth2_mutex: Mutex::new(()),
             translated_stockstrings: RwLock::new(HashMap::new()),
-            events: Events::default(),
-            scheduler: RwLock::new(Scheduler::Stopped),
             creation_time: std::time::SystemTime::now(),
         };
 
-        let ctx = Context {
-            inner: Arc::new(inner),
-        };
         ensure!(
-            ctx.sql.open(&ctx, &ctx.dbfile, false).await,
+            ctx.sql.open(&ctx, &ctx.dbfile, false),
             "Failed opening sqlite database"
         );
 
         Ok(ctx)
     }
 
-    /// Starts the IO scheduler.
-    pub async fn start_io(&self) {
-        info!(self, "starting IO");
-        if self.is_io_running().await {
-            info!(self, "IO is already running");
-            return;
-        }
-
-        {
-            let l = &mut *self.inner.scheduler.write().await;
-            l.start(self.clone()).await;
-        }
-    }
-
-    /// Returns if the IO scheduler is running.
-    pub async fn is_io_running(&self) -> bool {
-        self.inner.is_io_running().await
-    }
-
-    /// Stops the IO scheduler.
-    pub async fn stop_io(&self) {
-        info!(self, "stopping IO");
-        if !self.is_io_running().await {
-            info!(self, "IO is not running");
-            return;
-        }
-
-        self.inner.stop_io().await;
-    }
-
-    /// Returns a reference to the underlying SQL instance.
-    ///
-    /// Warning: this is only here for testing, not part of the public API.
-    #[cfg(feature = "internals")]
-    pub fn sql(&self) -> &Sql {
-        &self.inner.sql
-    }
-
     /// Returns database file path.
     pub fn get_dbfile(&self) -> &Path {
         self.dbfile.as_path()
@@ -183,57 +162,49 @@ impl Context {
         self.blobdir.as_path()
     }
 
-    /// Emits a single event.
-    pub fn emit_event(&self, event: Event) {
-        self.events.emit(event);
+    pub fn call_cb(&self, event: Event) {
+        (*self.cb)(self, event);
     }
 
-    /// Get the next queued event.
-    pub fn get_event_emitter(&self) -> EventEmitter {
-        self.events.get_emitter()
-    }
+    /*******************************************************************************
+     * Ongoing process allocation/free/check
+     ******************************************************************************/
 
-    // Ongoing process allocation/free/check
+    pub fn alloc_ongoing(&self) -> bool {
+        if self.has_ongoing() {
+            warn!(self, "There is already another ongoing process running.",);
 
-    pub async fn alloc_ongoing(&self) -> Result<Receiver<()>> {
-        if self.has_ongoing().await {
-            bail!("There is already another ongoing process running.");
+            false
+        } else {
+            let s_a = self.running_state.clone();
+            let mut s = s_a.write().unwrap();
+
+            s.ongoing_running = true;
+            s.shall_stop_ongoing = false;
+
+            true
         }
-
-        let s_a = &self.running_state;
-        let mut s = s_a.write().await;
-
-        s.ongoing_running = true;
-        s.shall_stop_ongoing = false;
-        let (sender, receiver) = channel(1);
-        s.cancel_sender = Some(sender);
-
-        Ok(receiver)
     }
 
-    pub async fn free_ongoing(&self) {
-        let s_a = &self.running_state;
-        let mut s = s_a.write().await;
+    pub fn free_ongoing(&self) {
+        let s_a = self.running_state.clone();
+        let mut s = s_a.write().unwrap();
 
         s.ongoing_running = false;
         s.shall_stop_ongoing = true;
-        s.cancel_sender.take();
     }
 
-    pub async fn has_ongoing(&self) -> bool {
-        let s_a = &self.running_state;
-        let s = s_a.read().await;
+    pub fn has_ongoing(&self) -> bool {
+        let s_a = self.running_state.clone();
+        let s = s_a.read().unwrap();
 
         s.ongoing_running || !s.shall_stop_ongoing
     }
 
     /// Signal an ongoing process to stop.
-    pub async fn stop_ongoing(&self) {
-        let s_a = &self.running_state;
-        let mut s = s_a.write().await;
-        if let Some(cancel) = s.cancel_sender.take() {
-            cancel.send(()).await;
-        }
+    pub fn stop_ongoing(&self) {
+        let s_a = self.running_state.clone();
+        let mut s = s_a.write().unwrap();
 
         if s.ongoing_running && !s.shall_stop_ongoing {
             info!(self, "Signaling the ongoing process to stop ASAP.",);
@@ -243,71 +214,71 @@ impl Context {
         };
     }
 
-    pub async fn shall_stop_ongoing(&self) -> bool {
-        self.running_state.read().await.shall_stop_ongoing
+    pub fn shall_stop_ongoing(&self) -> bool {
+        self.running_state
+            .clone()
+            .read()
+            .unwrap()
+            .shall_stop_ongoing
     }
 
     /*******************************************************************************
      * UI chat/message related API
      ******************************************************************************/
 
-    pub async fn get_info(&self) -> BTreeMap<&'static str, String> {
+    pub fn get_info(&self) -> BTreeMap<&'static str, String> {
         let unset = "0";
-        let l = LoginParam::from_database(self, "").await;
-        let l2 = LoginParam::from_database(self, "configured_").await;
-        let displayname = self.get_config(Config::Displayname).await;
-        let chats = get_chat_cnt(self).await as usize;
-        let real_msgs = message::get_real_msg_cnt(self).await as usize;
-        let deaddrop_msgs = message::get_deaddrop_msg_cnt(self).await as usize;
-        let contacts = Contact::get_real_cnt(self).await as usize;
-        let is_configured = self.get_config_int(Config::Configured).await;
+        let l = LoginParam::from_database(self, "");
+        let l2 = LoginParam::from_database(self, "configured_");
+        let displayname = self.get_config(Config::Displayname);
+        let chats = get_chat_cnt(self) as usize;
+        let real_msgs = message::get_real_msg_cnt(self) as usize;
+        let deaddrop_msgs = message::get_deaddrop_msg_cnt(self) as usize;
+        let contacts = Contact::get_real_cnt(self) as usize;
+        let is_configured = self.get_config_int(Config::Configured);
         let dbversion = self
             .sql
             .get_raw_config_int(self, "dbversion")
-            .await
             .unwrap_or_default();
         let journal_mode = self
             .sql
-            .query_get_value(self, "PRAGMA journal_mode;", paramsv![])
-            .await
+            .query_get_value(self, "PRAGMA journal_mode;", rusqlite::NO_PARAMS)
             .unwrap_or_else(|| "unknown".to_string());
-        let e2ee_enabled = self.get_config_int(Config::E2eeEnabled).await;
-        let mdns_enabled = self.get_config_int(Config::MdnsEnabled).await;
-        let bcc_self = self.get_config_int(Config::BccSelf).await;
+        let e2ee_enabled = self.get_config_int(Config::E2eeEnabled);
+        let mdns_enabled = self.get_config_int(Config::MdnsEnabled);
+        let bcc_self = self.get_config_int(Config::BccSelf);
 
-        let prv_key_cnt: Option<isize> = self
-            .sql
-            .query_get_value(self, "SELECT COUNT(*) FROM keypairs;", paramsv![])
-            .await;
+        let prv_key_cnt: Option<isize> =
+            self.sql
+                .query_get_value(self, "SELECT COUNT(*) FROM keypairs;", rusqlite::NO_PARAMS);
 
-        let pub_key_cnt: Option<isize> = self
-            .sql
-            .query_get_value(self, "SELECT COUNT(*) FROM acpeerstates;", paramsv![])
-            .await;
-        let fingerprint_str = match SignedPublicKey::load_self(self).await {
-            Ok(key) => key.fingerprint().hex(),
+        let pub_key_cnt: Option<isize> = self.sql.query_get_value(
+            self,
+            "SELECT COUNT(*) FROM acpeerstates;",
+            rusqlite::NO_PARAMS,
+        );
+
+        let fingerprint_str = match SignedPublicKey::load_self(self) {
+            Ok(key) => Key::from(key).fingerprint(),
             Err(err) => format!("<key failure: {}>", err),
         };
 
-        let inbox_watch = self.get_config_int(Config::InboxWatch).await;
-        let sentbox_watch = self.get_config_int(Config::SentboxWatch).await;
-        let mvbox_watch = self.get_config_int(Config::MvboxWatch).await;
-        let mvbox_move = self.get_config_int(Config::MvboxMove).await;
+        let inbox_watch = self.get_config_int(Config::InboxWatch);
+        let sentbox_watch = self.get_config_int(Config::SentboxWatch);
+        let mvbox_watch = self.get_config_int(Config::MvboxWatch);
+        let mvbox_move = self.get_config_int(Config::MvboxMove);
         let folders_configured = self
             .sql
             .get_raw_config_int(self, "folders_configured")
-            .await
             .unwrap_or_default();
 
         let configured_sentbox_folder = self
             .sql
             .get_raw_config(self, "configured_sentbox_folder")
-            .await
             .unwrap_or_else(|| "<unset>".to_string());
         let configured_mvbox_folder = self
             .sql
             .get_raw_config(self, "configured_mvbox_folder")
-            .await
             .unwrap_or_else(|| "<unset>".to_string());
 
         let mut res = get_info();
@@ -323,7 +294,6 @@ impl Context {
         res.insert(
             "selfavatar",
             self.get_config(Config::Selfavatar)
-                .await
                 .unwrap_or_else(|| "<unset>".to_string()),
         );
         res.insert("is_configured", is_configured.to_string());
@@ -355,8 +325,8 @@ impl Context {
         res
     }
 
-    pub async fn get_fresh_msgs(&self) -> Vec<MsgId> {
-        let show_deaddrop: i32 = 0;
+    pub fn get_fresh_msgs(&self) -> Vec<MsgId> {
+        let show_deaddrop = 0;
         self.sql
             .query_map(
                 concat!(
@@ -373,7 +343,7 @@ impl Context {
                     "   AND (c.blocked=0 OR c.blocked=?)",
                     " ORDER BY m.timestamp DESC,m.id DESC;"
                 ),
-                paramsv![10, 9, if 0 != show_deaddrop { 2 } else { 0 }],
+                &[10, 9, if 0 != show_deaddrop { 2 } else { 0 }],
                 |row| row.get::<_, MsgId>(0),
                 |rows| {
                     let mut ret = Vec::new();
@@ -383,12 +353,11 @@ impl Context {
                     Ok(ret)
                 },
             )
-            .await
             .unwrap_or_default()
     }
 
     #[allow(non_snake_case)]
-    pub async fn search_msgs(&self, chat_id: ChatId, query: impl AsRef<str>) -> Vec<MsgId> {
+    pub fn search_msgs(&self, chat_id: ChatId, query: impl AsRef<str>) -> Vec<MsgId> {
         let real_query = query.as_ref().trim();
         if real_query.is_empty() {
             return Vec::new();
@@ -428,7 +397,7 @@ impl Context {
         self.sql
             .query_map(
                 query,
-                paramsv![chat_id, strLikeInText, strLikeBeg],
+                params![chat_id, &strLikeInText, &strLikeBeg],
                 |row| row.get::<_, MsgId>("id"),
                 |rows| {
                     let mut ret = Vec::new();
@@ -438,7 +407,6 @@ impl Context {
                     Ok(ret)
                 },
             )
-            .await
             .unwrap_or_default()
     }
 
@@ -446,11 +414,8 @@ impl Context {
         folder_name.as_ref() == "INBOX"
     }
 
-    pub async fn is_sentbox(&self, folder_name: impl AsRef<str>) -> bool {
-        let sentbox_name = self
-            .sql
-            .get_raw_config(self, "configured_sentbox_folder")
-            .await;
+    pub fn is_sentbox(&self, folder_name: impl AsRef<str>) -> bool {
+        let sentbox_name = self.sql.get_raw_config(self, "configured_sentbox_folder");
         if let Some(name) = sentbox_name {
             name == folder_name.as_ref()
         } else {
@@ -458,11 +423,8 @@ impl Context {
         }
     }
 
-    pub async fn is_mvbox(&self, folder_name: impl AsRef<str>) -> bool {
-        let mvbox_name = self
-            .sql
-            .get_raw_config(self, "configured_mvbox_folder")
-            .await;
+    pub fn is_mvbox(&self, folder_name: impl AsRef<str>) -> bool {
+        let mvbox_name = self.sql.get_raw_config(self, "configured_mvbox_folder");
 
         if let Some(name) = mvbox_name {
             name == folder_name.as_ref()
@@ -471,15 +433,15 @@ impl Context {
         }
     }
 
-    pub async fn do_heuristics_moves(&self, folder: &str, msg_id: MsgId) {
-        if !self.get_config_bool(Config::MvboxMove).await {
+    pub fn do_heuristics_moves(&self, folder: &str, msg_id: MsgId) {
+        if !self.get_config_bool(Config::MvboxMove) {
             return;
         }
 
-        if self.is_mvbox(folder).await {
+        if self.is_mvbox(folder) {
             return;
         }
-        if let Ok(msg) = Message::load_from_db(self, msg_id).await {
+        if let Ok(msg) = Message::load_from_db(self, msg_id) {
             if msg.is_setupmessage() {
                 // do not move setup messages;
                 // there may be a non-delta device that wants to handle it
@@ -489,32 +451,30 @@ impl Context {
             match msg.is_dc_message {
                 MessengerMessage::No => {}
                 MessengerMessage::Yes | MessengerMessage::Reply => {
-                    job::add(
+                    job_add(
                         self,
-                        job::Job::new(Action::MoveMsg, msg.id.to_u32(), Params::new(), 0),
-                    )
-                    .await;
+                        Action::MoveMsg,
+                        msg.id.to_u32() as i32,
+                        Params::new(),
+                        0,
+                    );
                 }
             }
         }
     }
 }
 
-impl InnerContext {
-    async fn is_io_running(&self) -> bool {
-        self.scheduler.read().await.is_running()
-    }
-
-    async fn stop_io(&self) {
-        assert!(self.is_io_running().await, "context is already stopped");
-        let token = {
-            let lock = &*self.scheduler.read().await;
-            lock.pre_stop().await
-        };
-        {
-            let lock = &mut *self.scheduler.write().await;
-            lock.stop(token).await;
-        }
+impl Drop for Context {
+    fn drop(&mut self) {
+        info!(self, "disconnecting inbox-thread",);
+        self.inbox_thread.read().unwrap().imap.disconnect(self);
+        info!(self, "disconnecting sentbox-thread",);
+        self.sentbox_thread.read().unwrap().imap.disconnect(self);
+        info!(self, "disconnecting mvbox-thread",);
+        self.mvbox_thread.read().unwrap().imap.disconnect(self);
+        info!(self, "disconnecting SMTP");
+        self.smtp.clone().lock().unwrap().disconnect();
+        self.sql.close(self);
     }
 }
 
@@ -523,7 +483,6 @@ impl Default for RunningState {
         RunningState {
             ongoing_running: false,
             shall_stop_ongoing: true,
-            cancel_sender: None,
         }
     }
 }
@@ -535,6 +494,28 @@ pub(crate) struct BobStatus {
     pub qr_scan: Option<Lot>,
 }
 
+#[derive(Debug, PartialEq)]
+pub(crate) enum PerformJobsNeeded {
+    Not,
+    AtOnce,
+    AvoidDos,
+}
+
+impl Default for PerformJobsNeeded {
+    fn default() -> Self {
+        Self::Not
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct SmtpState {
+    pub idle: bool,
+    pub suspended: bool,
+    pub doing_jobs: bool,
+    pub(crate) perform_jobs_needed: PerformJobsNeeded,
+    pub probe_network: bool,
+}
+
 pub fn get_version_str() -> &'static str {
     &DC_VERSION_STR
 }
@@ -545,81 +526,81 @@ mod tests {
 
     use crate::test_utils::*;
 
-    #[async_std::test]
-    async fn test_wrong_db() {
+    #[test]
+    fn test_wrong_db() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
         std::fs::write(&dbfile, b"123").unwrap();
-        let res = Context::new("FakeOs".into(), dbfile.into()).await;
+        let res = Context::new(Box::new(|_, _| ()), "FakeOs".into(), dbfile);
         assert!(res.is_err());
     }
 
-    #[async_std::test]
-    async fn test_get_fresh_msgs() {
-        let t = dummy_context().await;
-        let fresh = t.ctx.get_fresh_msgs().await;
+    #[test]
+    fn test_get_fresh_msgs() {
+        let t = dummy_context();
+        let fresh = t.ctx.get_fresh_msgs();
         assert!(fresh.is_empty())
     }
 
-    #[async_std::test]
-    async fn test_blobdir_exists() {
+    #[test]
+    fn test_blobdir_exists() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
-        Context::new("FakeOS".into(), dbfile.into()).await.unwrap();
+        Context::new(Box::new(|_, _| ()), "FakeOS".into(), dbfile).unwrap();
         let blobdir = tmp.path().join("db.sqlite-blobs");
         assert!(blobdir.is_dir());
     }
 
-    #[async_std::test]
-    async fn test_wrong_blogdir() {
+    #[test]
+    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("FakeOS".into(), dbfile.into()).await;
+        let res = Context::new(Box::new(|_, _| ()), "FakeOS".into(), dbfile);
         assert!(res.is_err());
     }
 
-    #[async_std::test]
-    async fn test_sqlite_parent_not_exists() {
+    #[test]
+    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("FakeOS".into(), dbfile.into()).await.unwrap();
+        Context::new(Box::new(|_, _| ()), "FakeOS".into(), dbfile).unwrap();
         assert!(subdir.is_dir());
         assert!(dbfile2.is_file());
     }
 
-    #[async_std::test]
-    async fn test_with_empty_blobdir() {
+    #[test]
+    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("FakeOS".into(), dbfile.into(), blobdir.into()).await;
+        let res = Context::with_blobdir(Box::new(|_, _| ()), "FakeOS".into(), dbfile, blobdir);
         assert!(res.is_err());
     }
 
-    #[async_std::test]
-    async fn test_with_blobdir_not_exists() {
+    #[test]
+    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("FakeOS".into(), dbfile.into(), blobdir.into()).await;
+        let res = Context::with_blobdir(Box::new(|_, _| ()), "FakeOS".into(), dbfile, blobdir);
         assert!(res.is_err());
     }
 
-    #[async_std::test]
-    async fn no_crashes_on_context_deref() {
-        let t = dummy_context().await;
+    #[test]
+    fn no_crashes_on_context_deref() {
+        let t = dummy_context();
         std::mem::drop(t.ctx);
     }
 
-    #[async_std::test]
-    async fn test_get_info() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_get_info() {
+        let t = dummy_context();
 
-        let info = t.ctx.get_info().await;
+        let info = t.ctx.get_info();
         assert!(info.get("database_dir").is_some());
     }
 

src/dc_tools.rs

@@ -3,12 +3,11 @@
 
 use core::cmp::{max, min};
 use std::borrow::Cow;
-use std::fmt;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::{Duration, SystemTime};
+use std::{fmt, fs};
 
-use async_std::path::{Path, PathBuf};
-use async_std::{fs, io};
 use chrono::{Local, TimeZone};
 use rand::{thread_rng, Rng};
 
@@ -108,9 +107,9 @@ const MAX_SECONDS_TO_LEND_FROM_FUTURE: i64 = 5;
 // returns the currently smeared timestamp,
 // may be used to check if call to dc_create_smeared_timestamp() is needed or not.
 // the returned timestamp MUST NOT be used to be sent out or saved in the database!
-pub(crate) async fn dc_smeared_time(context: &Context) -> i64 {
+pub(crate) fn dc_smeared_time(context: &Context) -> i64 {
     let mut now = time();
-    let ts = *context.last_smeared_timestamp.read().await;
+    let ts = *context.last_smeared_timestamp.read().unwrap();
     if ts >= now {
         now = ts + 1;
     }
@@ -119,11 +118,11 @@ pub(crate) async fn dc_smeared_time(context: &Context) -> i64 {
 }
 
 // returns a timestamp that is guaranteed to be unique.
-pub(crate) async fn dc_create_smeared_timestamp(context: &Context) -> i64 {
+pub(crate) fn dc_create_smeared_timestamp(context: &Context) -> i64 {
     let now = time();
     let mut ret = now;
 
-    let mut last_smeared_timestamp = context.last_smeared_timestamp.write().await;
+    let mut last_smeared_timestamp = context.last_smeared_timestamp.write().unwrap();
     if ret <= *last_smeared_timestamp {
         ret = *last_smeared_timestamp + 1;
         if ret - now > MAX_SECONDS_TO_LEND_FROM_FUTURE {
@@ -138,12 +137,12 @@ pub(crate) async fn dc_create_smeared_timestamp(context: &Context) -> i64 {
 // creates `count` timestamps that are guaranteed to be unique.
 // the frist created timestamps is returned directly,
 // get the other timestamps just by adding 1..count-1
-pub(crate) async fn dc_create_smeared_timestamps(context: &Context, count: usize) -> i64 {
+pub(crate) fn dc_create_smeared_timestamps(context: &Context, count: usize) -> i64 {
     let now = time();
     let count = count as i64;
     let mut start = now + min(count, MAX_SECONDS_TO_LEND_FROM_FUTURE) - count;
 
-    let mut last_smeared_timestamp = context.last_smeared_timestamp.write().await;
+    let mut last_smeared_timestamp = context.last_smeared_timestamp.write().unwrap();
     start = max(*last_smeared_timestamp + 1, start);
 
     *last_smeared_timestamp = start + count - 1;
@@ -249,8 +248,11 @@ pub fn dc_get_filemeta(buf: &[u8]) -> Result<(u32, u32), Error> {
 ///
 /// If `path` starts with "$BLOBDIR", replaces it with the blobdir path.
 /// Otherwise, returns path as is.
-pub(crate) fn dc_get_abs_path<P: AsRef<Path>>(context: &Context, path: P) -> PathBuf {
-    let p: &Path = path.as_ref();
+pub(crate) fn dc_get_abs_path<P: AsRef<std::path::Path>>(
+    context: &Context,
+    path: P,
+) -> std::path::PathBuf {
+    let p: &std::path::Path = path.as_ref();
     if let Ok(p) = p.strip_prefix("$BLOBDIR") {
         context.get_blobdir().join(p)
     } else {
@@ -258,20 +260,20 @@ pub(crate) fn dc_get_abs_path<P: AsRef<Path>>(context: &Context, path: P) -> Pat
     }
 }
 
-pub(crate) async fn dc_get_filebytes(context: &Context, path: impl AsRef<Path>) -> u64 {
+pub(crate) fn dc_get_filebytes(context: &Context, path: impl AsRef<std::path::Path>) -> u64 {
     let path_abs = dc_get_abs_path(context, &path);
-    match fs::metadata(&path_abs).await {
+    match fs::metadata(&path_abs) {
         Ok(meta) => meta.len() as u64,
         Err(_err) => 0,
     }
 }
 
-pub(crate) async fn dc_delete_file(context: &Context, path: impl AsRef<Path>) -> bool {
+pub(crate) fn dc_delete_file(context: &Context, path: impl AsRef<std::path::Path>) -> bool {
     let path_abs = dc_get_abs_path(context, &path);
-    if !path_abs.exists().await {
+    if !path_abs.exists() {
         return false;
     }
-    if !path_abs.is_file().await {
+    if !path_abs.is_file() {
         warn!(
             context,
             "refusing to delete non-file \"{}\".",
@@ -281,9 +283,9 @@ pub(crate) async fn dc_delete_file(context: &Context, path: impl AsRef<Path>) ->
     }
 
     let dpath = format!("{}", path.as_ref().to_string_lossy());
-    match fs::remove_file(path_abs).await {
+    match fs::remove_file(path_abs) {
         Ok(_) => {
-            context.emit_event(Event::DeletedBlobFile(dpath));
+            context.call_cb(Event::DeletedBlobFile(dpath));
             true
         }
         Err(err) => {
@@ -293,13 +295,13 @@ pub(crate) async fn dc_delete_file(context: &Context, path: impl AsRef<Path>) ->
     }
 }
 
-pub(crate) async fn dc_copy_file(
+pub(crate) fn dc_copy_file(
     context: &Context,
-    src_path: impl AsRef<Path>,
-    dest_path: impl AsRef<Path>,
+    src_path: impl AsRef<std::path::Path>,
+    dest_path: impl AsRef<std::path::Path>,
 ) -> bool {
     let src_abs = dc_get_abs_path(context, &src_path);
-    let mut src_file = match fs::File::open(&src_abs).await {
+    let mut src_file = match fs::File::open(&src_abs) {
         Ok(file) => file,
         Err(err) => {
             warn!(
@@ -317,7 +319,6 @@ pub(crate) async fn dc_copy_file(
         .create_new(true)
         .write(true)
         .open(&dest_abs)
-        .await
     {
         Ok(file) => file,
         Err(err) => {
@@ -331,7 +332,7 @@ pub(crate) async fn dc_copy_file(
         }
     };
 
-    match io::copy(&mut src_file, &mut dest_file).await {
+    match std::io::copy(&mut src_file, &mut dest_file) {
         Ok(_) => true,
         Err(err) => {
             error!(
@@ -343,20 +344,20 @@ pub(crate) async fn dc_copy_file(
             );
             {
                 // Attempt to remove the failed file, swallow errors resulting from that.
-                fs::remove_file(dest_abs).await.ok();
+                fs::remove_file(dest_abs).ok();
             }
             false
         }
     }
 }
 
-pub(crate) async fn dc_create_folder(
+pub(crate) fn dc_create_folder(
     context: &Context,
-    path: impl AsRef<Path>,
-) -> Result<(), io::Error> {
+    path: impl AsRef<std::path::Path>,
+) -> Result<(), std::io::Error> {
     let path_abs = dc_get_abs_path(context, &path);
-    if !path_abs.exists().await {
-        match fs::create_dir_all(path_abs).await {
+    if !path_abs.exists() {
+        match fs::create_dir_all(path_abs) {
             Ok(_) => Ok(()),
             Err(err) => {
                 warn!(
@@ -374,13 +375,13 @@ pub(crate) async fn dc_create_folder(
 }
 
 /// Write a the given content to provied file path.
-pub(crate) async fn dc_write_file(
+pub(crate) fn dc_write_file(
     context: &Context,
     path: impl AsRef<Path>,
     buf: &[u8],
-) -> Result<(), io::Error> {
+) -> Result<(), std::io::Error> {
     let path_abs = dc_get_abs_path(context, &path);
-    fs::write(&path_abs, buf).await.map_err(|err| {
+    fs::write(&path_abs, buf).map_err(|err| {
         warn!(
             context,
             "Cannot write {} bytes to \"{}\": {}",
@@ -392,10 +393,13 @@ pub(crate) async fn dc_write_file(
     })
 }
 
-pub async fn dc_read_file<P: AsRef<Path>>(context: &Context, path: P) -> Result<Vec<u8>, Error> {
+pub fn dc_read_file<P: AsRef<std::path::Path>>(
+    context: &Context,
+    path: P,
+) -> Result<Vec<u8>, Error> {
     let path_abs = dc_get_abs_path(context, &path);
 
-    match fs::read(&path_abs).await {
+    match fs::read(&path_abs) {
         Ok(bytes) => Ok(bytes),
         Err(err) => {
             warn!(
@@ -409,31 +413,13 @@ pub async fn dc_read_file<P: AsRef<Path>>(context: &Context, path: P) -> Result<
     }
 }
 
-pub async fn dc_open_file<P: AsRef<Path>>(context: &Context, path: P) -> Result<fs::File, Error> {
-    let path_abs = dc_get_abs_path(context, &path);
-
-    match fs::File::open(&path_abs).await {
-        Ok(bytes) => Ok(bytes),
-        Err(err) => {
-            warn!(
-                context,
-                "Cannot read \"{}\" or file is empty: {}",
-                path.as_ref().display(),
-                err
-            );
-            Err(err.into())
-        }
-    }
-}
-
-pub fn dc_open_file_std<P: AsRef<std::path::Path>>(
+pub fn dc_open_file<P: AsRef<std::path::Path>>(
     context: &Context,
     path: P,
 ) -> Result<std::fs::File, Error> {
-    let p: PathBuf = path.as_ref().into();
-    let path_abs = dc_get_abs_path(context, p);
+    let path_abs = dc_get_abs_path(context, &path);
 
-    match std::fs::File::open(&path_abs) {
+    match fs::File::open(&path_abs) {
         Ok(bytes) => Ok(bytes),
         Err(err) => {
             warn!(
@@ -447,7 +433,7 @@ pub fn dc_open_file_std<P: AsRef<std::path::Path>>(
     }
 }
 
-pub(crate) async fn dc_get_next_backup_path(
+pub(crate) fn dc_get_next_backup_path(
     folder: impl AsRef<Path>,
     backup_time: i64,
 ) -> Result<PathBuf, Error> {
@@ -460,7 +446,7 @@ pub(crate) async fn dc_get_next_backup_path(
     for i in 0..64 {
         let mut path = folder.clone();
         path.push(format!("{}-{}.bak", stem, i));
-        if !path.exists().await {
+        if !path.exists() {
             return Ok(path);
         }
     }
@@ -482,6 +468,15 @@ pub struct InvalidEmailError {
     addr: String,
 }
 
+impl InvalidEmailError {
+    fn new(msg: impl Into<String>, addr: impl Into<String>) -> InvalidEmailError {
+        InvalidEmailError {
+            message: msg.into(),
+            addr: addr.into(),
+        }
+    }
+}
+
 /// Very simple email address wrapper.
 ///
 /// Represents an email address, right now just the `name@domain` portion.
@@ -521,24 +516,17 @@ impl FromStr for EmailAddress {
 
     /// Performs a dead-simple parse of an email address.
     fn from_str(input: &str) -> Result<EmailAddress, InvalidEmailError> {
+        if input.is_empty() {
+            return Err(InvalidEmailError::new("empty string is not valid", input));
+        }
+        let parts: Vec<&str> = input.rsplitn(2, '@').collect();
+
         let err = |msg: &str| {
             Err(InvalidEmailError {
                 message: msg.to_string(),
                 addr: input.to_string(),
             })
         };
-        if input.is_empty() {
-            return err("empty string is not valid");
-        }
-        let parts: Vec<&str> = input.rsplitn(2, '@').collect();
-
-        if input
-            .chars()
-            .any(|c| c.is_whitespace() || c == '<' || c == '>')
-        {
-            return err("Email must not contain whitespaces, '>' or '<'");
-        }
-
         match &parts[..] {
             [domain, local] => {
                 if local.is_empty() {
@@ -772,35 +760,31 @@ mod tests {
         }
     }
 
-    #[async_std::test]
-    async fn test_file_handling() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_file_handling() {
+        let t = dummy_context();
         let context = &t.ctx;
-        macro_rules! dc_file_exist {
-            ($ctx:expr, $fname:expr) => {
-                $ctx.get_blobdir()
-                    .join(Path::new($fname).file_name().unwrap())
-                    .exists()
-            };
-        }
+        let dc_file_exist = |ctx: &Context, fname: &str| {
+            ctx.get_blobdir()
+                .join(Path::new(fname).file_name().unwrap())
+                .exists()
+        };
 
-        assert!(!dc_delete_file(context, "$BLOBDIR/lkqwjelqkwlje").await);
-        if dc_file_exist!(context, "$BLOBDIR/foobar").await
-            || dc_file_exist!(context, "$BLOBDIR/dada").await
-            || dc_file_exist!(context, "$BLOBDIR/foobar.dadada").await
-            || dc_file_exist!(context, "$BLOBDIR/foobar-folder").await
+        assert!(!dc_delete_file(context, "$BLOBDIR/lkqwjelqkwlje"));
+        if dc_file_exist(context, "$BLOBDIR/foobar")
+            || dc_file_exist(context, "$BLOBDIR/dada")
+            || dc_file_exist(context, "$BLOBDIR/foobar.dadada")
+            || dc_file_exist(context, "$BLOBDIR/foobar-folder")
         {
-            dc_delete_file(context, "$BLOBDIR/foobar").await;
-            dc_delete_file(context, "$BLOBDIR/dada").await;
-            dc_delete_file(context, "$BLOBDIR/foobar.dadada").await;
-            dc_delete_file(context, "$BLOBDIR/foobar-folder").await;
+            dc_delete_file(context, "$BLOBDIR/foobar");
+            dc_delete_file(context, "$BLOBDIR/dada");
+            dc_delete_file(context, "$BLOBDIR/foobar.dadada");
+            dc_delete_file(context, "$BLOBDIR/foobar-folder");
         }
-        assert!(dc_write_file(context, "$BLOBDIR/foobar", b"content")
-            .await
-            .is_ok());
-        assert!(dc_file_exist!(context, "$BLOBDIR/foobar").await);
-        assert!(!dc_file_exist!(context, "$BLOBDIR/foobarx").await);
-        assert_eq!(dc_get_filebytes(context, "$BLOBDIR/foobar").await, 7);
+        assert!(dc_write_file(context, "$BLOBDIR/foobar", b"content").is_ok());
+        assert!(dc_file_exist(context, "$BLOBDIR/foobar",));
+        assert!(!dc_file_exist(context, "$BLOBDIR/foobarx"));
+        assert_eq!(dc_get_filebytes(context, "$BLOBDIR/foobar"), 7);
 
         let abs_path = context
             .get_blobdir()
@@ -808,33 +792,31 @@ mod tests {
             .to_string_lossy()
             .to_string();
 
-        assert!(dc_file_exist!(context, &abs_path).await);
+        assert!(dc_file_exist(context, &abs_path));
 
-        assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada").await);
+        assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
 
         // attempting to copy a second time should fail
-        assert!(!dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada").await);
+        assert!(!dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
 
-        assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada").await, 7);
+        assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada",), 7);
 
-        let buf = dc_read_file(context, "$BLOBDIR/dada").await.unwrap();
+        let buf = dc_read_file(context, "$BLOBDIR/dada").unwrap();
 
         assert_eq!(buf.len(), 7);
         assert_eq!(&buf, b"content");
 
-        assert!(dc_delete_file(context, "$BLOBDIR/foobar").await);
-        assert!(dc_delete_file(context, "$BLOBDIR/dada").await);
-        assert!(dc_create_folder(context, "$BLOBDIR/foobar-folder")
-            .await
-            .is_ok());
-        assert!(dc_file_exist!(context, "$BLOBDIR/foobar-folder").await);
-        assert!(!dc_delete_file(context, "$BLOBDIR/foobar-folder").await);
+        assert!(dc_delete_file(context, "$BLOBDIR/foobar"));
+        assert!(dc_delete_file(context, "$BLOBDIR/dada"));
+        assert!(dc_create_folder(context, "$BLOBDIR/foobar-folder").is_ok());
+        assert!(dc_file_exist(context, "$BLOBDIR/foobar-folder",));
+        assert!(!dc_delete_file(context, "$BLOBDIR/foobar-folder"));
 
         let fn0 = "$BLOBDIR/data.data";
-        assert!(dc_write_file(context, &fn0, b"content").await.is_ok());
+        assert!(dc_write_file(context, &fn0, b"content").is_ok());
 
-        assert!(dc_delete_file(context, &fn0).await);
-        assert!(!dc_file_exist!(context, &fn0).await);
+        assert!(dc_delete_file(context, &fn0));
+        assert!(!dc_file_exist(context, &fn0));
     }
 
     #[test]
@@ -851,15 +833,15 @@ mod tests {
         assert!(!listflags_has(listflags, DC_GCL_ADD_SELF));
     }
 
-    #[async_std::test]
-    async fn test_create_smeared_timestamp() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_create_smeared_timestamp() {
+        let t = dummy_context();
         assert_ne!(
-            dc_create_smeared_timestamp(&t.ctx).await,
-            dc_create_smeared_timestamp(&t.ctx).await
+            dc_create_smeared_timestamp(&t.ctx),
+            dc_create_smeared_timestamp(&t.ctx)
         );
         assert!(
-            dc_create_smeared_timestamp(&t.ctx).await
+            dc_create_smeared_timestamp(&t.ctx)
                 >= SystemTime::now()
                     .duration_since(SystemTime::UNIX_EPOCH)
                     .unwrap()
@@ -867,17 +849,17 @@ mod tests {
         );
     }
 
-    #[async_std::test]
-    async fn test_create_smeared_timestamps() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_create_smeared_timestamps() {
+        let t = dummy_context();
         let count = MAX_SECONDS_TO_LEND_FROM_FUTURE - 1;
-        let start = dc_create_smeared_timestamps(&t.ctx, count as usize).await;
-        let next = dc_smeared_time(&t.ctx).await;
+        let start = dc_create_smeared_timestamps(&t.ctx, count as usize);
+        let next = dc_smeared_time(&t.ctx);
         assert!((start + count - 1) < next);
 
         let count = MAX_SECONDS_TO_LEND_FROM_FUTURE + 30;
-        let start = dc_create_smeared_timestamps(&t.ctx, count as usize).await;
-        let next = dc_smeared_time(&t.ctx).await;
+        let start = dc_create_smeared_timestamps(&t.ctx, count as usize);
+        let next = dc_smeared_time(&t.ctx);
         assert!((start + count - 1) < next);
     }
 

src/e2ee.rs

@@ -11,7 +11,7 @@ use crate::context::Context;
 use crate::error::*;
 use crate::headerdef::HeaderDef;
 use crate::headerdef::HeaderDefMap;
-use crate::key::{DcKey, SignedPublicKey, SignedSecretKey};
+use crate::key::{DcKey, Key, SignedPublicKey, SignedSecretKey};
 use crate::keyring::*;
 use crate::peerstate::*;
 use crate::pgp;
@@ -25,18 +25,18 @@ pub struct EncryptHelper {
 }
 
 impl EncryptHelper {
-    pub async fn new(context: &Context) -> Result<EncryptHelper> {
+    pub fn new(context: &Context) -> Result<EncryptHelper> {
         let prefer_encrypt =
-            EncryptPreference::from_i32(context.get_config_int(Config::E2eeEnabled).await)
+            EncryptPreference::from_i32(context.get_config_int(Config::E2eeEnabled))
                 .unwrap_or_default();
-        let addr = match context.get_config(Config::ConfiguredAddr).await {
+        let addr = match context.get_config(Config::ConfiguredAddr) {
             None => {
                 bail!("addr not configured!");
             }
             Some(addr) => addr,
         };
 
-        let public_key = SignedPublicKey::load_self(context).await?;
+        let public_key = SignedPublicKey::load_self(context)?;
 
         Ok(EncryptHelper {
             prefer_encrypt,
@@ -86,36 +86,37 @@ impl EncryptHelper {
     }
 
     /// Tries to encrypt the passed in `mail`.
-    pub async fn encrypt(
-        self,
+    pub fn encrypt(
+        &mut self,
         context: &Context,
         min_verified: PeerstateVerifiedStatus,
         mail_to_encrypt: lettre_email::PartBuilder,
-        peerstates: Vec<(Option<Peerstate<'_>>, &str)>,
+        peerstates: &[(Option<Peerstate>, &str)],
     ) -> Result<String> {
-        let mut keyring: Keyring<SignedPublicKey> = Keyring::new();
+        let mut keyring = Keyring::default();
 
         for (peerstate, addr) in peerstates
-            .into_iter()
-            .filter_map(|(state, addr)| state.map(|s| (s, addr)))
+            .iter()
+            .filter_map(|(state, addr)| state.as_ref().map(|s| (s, addr)))
         {
-            let key = peerstate.take_key(min_verified).ok_or_else(|| {
+            let key = peerstate.peek_key(min_verified).ok_or_else(|| {
                 format_err!("proper enc-key for {} missing, cannot encrypt", addr)
             })?;
-            keyring.add(key);
+            keyring.add_ref(key);
         }
-        keyring.add(self.public_key.clone());
-        let sign_key = SignedSecretKey::load_self(context).await?;
+        let public_key = Key::from(self.public_key.clone());
+        keyring.add_ref(&public_key);
+        let sign_key = Key::from(SignedSecretKey::load_self(context)?);
 
         let raw_message = mail_to_encrypt.build().as_string().into_bytes();
 
-        let ctext = pgp::pk_encrypt(&raw_message, keyring, Some(sign_key)).await?;
+        let ctext = pgp::pk_encrypt(&raw_message, &keyring, Some(&sign_key))?;
 
         Ok(ctext)
     }
 }
 
-pub async fn try_decrypt(
+pub fn try_decrypt(
     context: &Context,
     mail: &ParsedMail<'_>,
     message_time: i64,
@@ -132,51 +133,56 @@ pub async fn try_decrypt(
     let autocryptheader = Aheader::from_headers(context, &from, &mail.headers);
 
     if message_time > 0 {
-        peerstate = Peerstate::from_addr(context, &from).await;
+        peerstate = Peerstate::from_addr(context, &context.sql, &from);
 
         if let Some(ref mut peerstate) = peerstate {
             if let Some(ref header) = autocryptheader {
                 peerstate.apply_header(&header, message_time);
-                peerstate.save_to_db(&context.sql, false).await?;
+                peerstate.save_to_db(&context.sql, false)?;
             } else if message_time > peerstate.last_seen_autocrypt && !contains_report(mail) {
                 peerstate.degrade_encryption(message_time);
-                peerstate.save_to_db(&context.sql, false).await?;
+                peerstate.save_to_db(&context.sql, false)?;
             }
         } else if let Some(ref header) = autocryptheader {
             let p = Peerstate::from_header(context, header, message_time);
-            p.save_to_db(&context.sql, true).await?;
+            p.save_to_db(&context.sql, true)?;
             peerstate = Some(p);
         }
     }
 
     /* possibly perform decryption */
-    let private_keyring: Keyring<SignedSecretKey> = Keyring::new_self(context).await?;
-    let mut public_keyring_for_validate: Keyring<SignedPublicKey> = Keyring::new();
+    let mut private_keyring = Keyring::default();
+    let mut public_keyring_for_validate = Keyring::default();
+    let mut out_mail = None;
     let mut signatures = HashSet::default();
+    let self_addr = context.get_config(Config::ConfiguredAddr);
 
-    if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 {
-        peerstate = Peerstate::from_addr(&context, &from).await;
-    }
-    if let Some(peerstate) = peerstate {
-        if peerstate.degrade_event.is_some() {
-            handle_degrade_event(context, &peerstate).await?;
-        }
-        if let Some(key) = peerstate.gossip_key {
-            public_keyring_for_validate.add(key);
-        }
-        if let Some(key) = peerstate.public_key {
-            public_keyring_for_validate.add(key);
+    if let Some(self_addr) = self_addr {
+        if private_keyring.load_self_private_for_decrypting(context, self_addr, &context.sql) {
+            if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 {
+                peerstate = Peerstate::from_addr(&context, &context.sql, &from);
+            }
+            if let Some(ref peerstate) = peerstate {
+                if peerstate.degrade_event.is_some() {
+                    handle_degrade_event(context, &peerstate)?;
+                }
+                if let Some(ref key) = peerstate.gossip_key {
+                    public_keyring_for_validate.add_ref(key);
+                }
+                if let Some(ref key) = peerstate.public_key {
+                    public_keyring_for_validate.add_ref(key);
+                }
+            }
+
+            out_mail = decrypt_if_autocrypt_message(
+                context,
+                mail,
+                &private_keyring,
+                &public_keyring_for_validate,
+                &mut signatures,
+            )?;
         }
     }
-
-    let out_mail = decrypt_if_autocrypt_message(
-        context,
-        mail,
-        private_keyring,
-        public_keyring_for_validate,
-        &mut signatures,
-    )
-    .await?;
     Ok((out_mail, signatures))
 }
 
@@ -207,11 +213,11 @@ fn get_autocrypt_mime<'a, 'b>(mail: &'a ParsedMail<'b>) -> Result<&'a ParsedMail
     Ok(&mail.subparts[1])
 }
 
-async fn decrypt_if_autocrypt_message<'a>(
+fn decrypt_if_autocrypt_message<'a>(
     context: &Context,
     mail: &ParsedMail<'a>,
-    private_keyring: Keyring<SignedSecretKey>,
-    public_keyring_for_validate: Keyring<SignedPublicKey>,
+    private_keyring: &Keyring,
+    public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
 ) -> Result<Option<Vec<u8>>> {
     //  The returned bool is true if we detected an Autocrypt-encrypted
@@ -231,19 +237,20 @@ async fn decrypt_if_autocrypt_message<'a>(
     info!(context, "Detected Autocrypt-mime message");
 
     decrypt_part(
+        context,
         encrypted_data_part,
         private_keyring,
         public_keyring_for_validate,
         ret_valid_signatures,
     )
-    .await
 }
 
 /// Returns Ok(None) if nothing encrypted was found.
-async fn decrypt_part(
+fn decrypt_part(
+    _context: &Context,
     mail: &ParsedMail<'_>,
-    private_keyring: Keyring<SignedSecretKey>,
-    public_keyring_for_validate: Keyring<SignedPublicKey>,
+    private_keyring: &Keyring,
+    public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
 ) -> Result<Option<Vec<u8>>> {
     let data = mail.get_body_raw()?;
@@ -253,12 +260,11 @@ async fn decrypt_part(
         ensure!(ret_valid_signatures.is_empty(), "corrupt signatures");
 
         let plain = pgp::pk_decrypt(
-            data,
-            private_keyring,
-            public_keyring_for_validate,
+            &data,
+            &private_keyring,
+            &public_keyring_for_validate,
             Some(ret_valid_signatures),
-        )
-        .await?;
+        )?;
 
         ensure!(!ret_valid_signatures.is_empty(), "no valid signatures");
         return Ok(Some(plain));
@@ -302,17 +308,14 @@ fn contains_report(mail: &ParsedMail<'_>) -> bool {
 /// If this succeeds you are also guaranteed that the
 /// [Config::ConfiguredAddr] is configured, this address is returned.
 // TODO, remove this once deltachat::key::Key no longer exists.
-pub async fn ensure_secret_key_exists(context: &Context) -> Result<String> {
-    let self_addr = context
-        .get_config(Config::ConfiguredAddr)
-        .await
-        .ok_or_else(|| {
-            format_err!(concat!(
-                "Failed to get self address, ",
-                "cannot ensure secret key if not configured."
-            ))
-        })?;
-    SignedPublicKey::load_self(context).await?;
+pub fn ensure_secret_key_exists(context: &Context) -> Result<String> {
+    let self_addr = context.get_config(Config::ConfiguredAddr).ok_or_else(|| {
+        format_err!(concat!(
+            "Failed to get self address, ",
+            "cannot ensure secret key if not configured."
+        ))
+    })?;
+    SignedPublicKey::load_self(context)?;
     Ok(self_addr)
 }
 
@@ -325,17 +328,17 @@ mod tests {
     mod ensure_secret_key_exists {
         use super::*;
 
-        #[async_std::test]
-        async fn test_prexisting() {
-            let t = dummy_context().await;
-            let test_addr = configure_alice_keypair(&t.ctx).await;
-            assert_eq!(ensure_secret_key_exists(&t.ctx).await.unwrap(), test_addr);
+        #[test]
+        fn test_prexisting() {
+            let t = dummy_context();
+            let test_addr = configure_alice_keypair(&t.ctx);
+            assert_eq!(ensure_secret_key_exists(&t.ctx).unwrap(), test_addr);
         }
 
-        #[async_std::test]
-        async fn test_not_configured() {
-            let t = dummy_context().await;
-            assert!(ensure_secret_key_exists(&t.ctx).await.is_err());
+        #[test]
+        fn test_not_configured() {
+            let t = dummy_context();
+            assert!(ensure_secret_key_exists(&t.ctx).is_err());
         }
     }
 

src/error.rs

@@ -2,6 +2,13 @@
 
 pub use anyhow::{bail, ensure, format_err, Error, Result};
 
+// #[fail(display = "Invalid Message ID.")]
+// InvalidMsgId,
+// #[fail(display = "Watch folder not found {:?}", _0)]
+// WatchFolderNotFound(String),
+// #[fail(display = "Not Configured")]
+// NotConfigured,
+
 #[macro_export]
 macro_rules! ensure_eq {
     ($left:expr, $right:expr) => ({

src/events.rs

@@ -1,65 +1,12 @@
 //! # Events specification
 
-use async_std::path::PathBuf;
-use async_std::sync::{channel, Receiver, Sender, TrySendError};
+use std::path::PathBuf;
+
 use strum::EnumProperty;
 
 use crate::chat::ChatId;
 use crate::message::MsgId;
 
-#[derive(Debug)]
-pub struct Events {
-    receiver: Receiver<Event>,
-    sender: Sender<Event>,
-}
-
-impl Default for Events {
-    fn default() -> Self {
-        let (sender, receiver) = channel(1_000);
-
-        Self { receiver, sender }
-    }
-}
-
-impl Events {
-    pub fn emit(&self, event: Event) {
-        match self.sender.try_send(event) {
-            Ok(()) => {}
-            Err(TrySendError::Full(event)) => {
-                // when we are full, we pop remove the oldest event and push on the new one
-                let _ = self.receiver.try_recv();
-
-                // try again
-                self.emit(event);
-            }
-            Err(TrySendError::Disconnected(_)) => {
-                unreachable!("unable to emit event, channel disconnected");
-            }
-        }
-    }
-
-    /// Retrieve the event emitter.
-    pub fn get_emitter(&self) -> EventEmitter {
-        EventEmitter(self.receiver.clone())
-    }
-}
-
-#[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())
-    }
-
-    /// Blocking async recv of an event. Return `None` if the `Sender` has been droped.
-    pub async fn recv(&self) -> Option<Event> {
-        // TODO: change once we can use async channels internally.
-        self.0.recv().await.ok()
-    }
-}
-
 impl Event {
     /// Returns the corresponding Event id.
     pub fn as_id(&self) -> i32 {

src/imap/client.rs

@@ -1,80 +1,20 @@
-use std::ops::{Deref, DerefMut};
-
 use async_imap::{
     error::{Error as ImapError, Result as ImapResult},
     Client as ImapClient,
 };
+use async_native_tls::TlsStream;
 use async_std::net::{self, TcpStream};
 
 use super::session::Session;
 use crate::login_param::{dc_build_tls, CertificateChecks};
 
-use super::session::SessionStream;
-
 #[derive(Debug)]
-pub(crate) struct Client {
-    is_secure: bool,
-    inner: ImapClient<Box<dyn SessionStream>>,
-}
-
-impl Deref for Client {
-    type Target = ImapClient<Box<dyn SessionStream>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl DerefMut for Client {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
+pub(crate) enum Client {
+    Secure(ImapClient<TlsStream<TcpStream>>),
+    Insecure(ImapClient<TcpStream>),
 }
 
 impl Client {
-    pub async fn login<U: AsRef<str>, P: AsRef<str>>(
-        self,
-        username: U,
-        password: P,
-    ) -> std::result::Result<Session, (ImapError, Self)> {
-        let Client { inner, is_secure } = self;
-        let session = inner
-            .login(username, password)
-            .await
-            .map_err(|(err, client)| {
-                (
-                    err,
-                    Client {
-                        is_secure,
-                        inner: client,
-                    },
-                )
-            })?;
-        Ok(Session { inner: session })
-    }
-
-    pub async fn authenticate<A: async_imap::Authenticator, S: AsRef<str>>(
-        self,
-        auth_type: S,
-        authenticator: &A,
-    ) -> std::result::Result<Session, (ImapError, Self)> {
-        let Client { inner, is_secure } = self;
-        let session =
-            inner
-                .authenticate(auth_type, authenticator)
-                .await
-                .map_err(|(err, client)| {
-                    (
-                        err,
-                        Client {
-                            is_secure,
-                            inner: client,
-                        },
-                    )
-                })?;
-        Ok(Session { inner: session })
-    }
-
     pub async fn connect_secure<A: net::ToSocketAddrs, S: AsRef<str>>(
         addr: A,
         domain: S,
@@ -82,8 +22,7 @@ impl Client {
     ) -> ImapResult<Self> {
         let stream = TcpStream::connect(addr).await?;
         let tls = dc_build_tls(certificate_checks);
-        let tls_stream: Box<dyn SessionStream> =
-            Box::new(tls.connect(domain.as_ref(), stream).await?);
+        let tls_stream = tls.connect(domain.as_ref(), stream).await?;
         let mut client = ImapClient::new(tls_stream);
         if std::env::var(crate::DCC_IMAP_DEBUG).is_ok() {
             client.debug = true;
@@ -94,14 +33,11 @@ impl Client {
             .await
             .ok_or_else(|| ImapError::Bad("failed to read greeting".to_string()))?;
 
-        Ok(Client {
-            is_secure: true,
-            inner: client,
-        })
+        Ok(Client::Secure(client))
     }
 
     pub async fn connect_insecure<A: net::ToSocketAddrs>(addr: A) -> ImapResult<Self> {
-        let stream: Box<dyn SessionStream> = Box::new(TcpStream::connect(addr).await?);
+        let stream = TcpStream::connect(addr).await?;
 
         let mut client = ImapClient::new(stream);
         if std::env::var(crate::DCC_IMAP_DEBUG).is_ok() {
@@ -112,10 +48,7 @@ impl Client {
             .await
             .ok_or_else(|| ImapError::Bad("failed to read greeting".to_string()))?;
 
-        Ok(Client {
-            is_secure: false,
-            inner: client,
-        })
+        Ok(Client::Insecure(client))
     }
 
     pub async fn secure<S: AsRef<str>>(
@@ -123,21 +56,49 @@ impl Client {
         domain: S,
         certificate_checks: CertificateChecks,
     ) -> ImapResult<Client> {
-        if self.is_secure {
-            Ok(self)
-        } else {
-            let Client { mut inner, .. } = self;
-            let tls = dc_build_tls(certificate_checks);
-            inner.run_command_and_check_ok("STARTTLS", None).await?;
+        match self {
+            Client::Insecure(client) => {
+                let tls = dc_build_tls(certificate_checks);
+                let client_sec = client.secure(domain, tls).await?;
 
-            let stream = inner.into_inner();
-            let ssl_stream = tls.connect(domain.as_ref(), stream).await?;
-            let boxed: Box<dyn SessionStream> = Box::new(ssl_stream);
+                Ok(Client::Secure(client_sec))
+            }
+            // Nothing to do
+            Client::Secure(_) => Ok(self),
+        }
+    }
 
-            Ok(Client {
-                is_secure: true,
-                inner: ImapClient::new(boxed),
-            })
+    pub async fn authenticate<A: async_imap::Authenticator, S: AsRef<str>>(
+        self,
+        auth_type: S,
+        authenticator: &A,
+    ) -> Result<Session, (ImapError, Client)> {
+        match self {
+            Client::Secure(i) => match i.authenticate(auth_type, authenticator).await {
+                Ok(session) => Ok(Session::Secure(session)),
+                Err((err, c)) => Err((err, Client::Secure(c))),
+            },
+            Client::Insecure(i) => match i.authenticate(auth_type, authenticator).await {
+                Ok(session) => Ok(Session::Insecure(session)),
+                Err((err, c)) => Err((err, Client::Insecure(c))),
+            },
+        }
+    }
+
+    pub async fn login<U: AsRef<str>, P: AsRef<str>>(
+        self,
+        username: U,
+        password: P,
+    ) -> Result<Session, (ImapError, Client)> {
+        match self {
+            Client::Secure(i) => match i.login(username, password).await {
+                Ok(session) => Ok(Session::Secure(session)),
+                Err((err, c)) => Err((err, Client::Secure(c))),
+            },
+            Client::Insecure(i) => match i.login(username, password).await {
+                Ok(session) => Ok(Session::Insecure(session)),
+                Err((err, c)) => Err((err, Client::Insecure(c))),
+            },
         }
     }
 }

src/imap/idle.rs

@@ -1,7 +1,11 @@
 use super::Imap;
 
-use async_imap::extensions::idle::IdleResponse;
+use async_imap::extensions::idle::{Handle as ImapIdleHandle, IdleResponse};
+use async_native_tls::TlsStream;
+use async_std::net::TcpStream;
 use async_std::prelude::*;
+use async_std::task;
+use std::sync::atomic::Ordering;
 use std::time::{Duration, SystemTime};
 
 use crate::context::Context;
@@ -29,199 +33,255 @@ pub enum Error {
     SetupHandleError(#[from] super::Error),
 }
 
+#[derive(Debug)]
+pub(crate) enum IdleHandle {
+    Secure(ImapIdleHandle<TlsStream<TcpStream>>),
+    Insecure(ImapIdleHandle<TcpStream>),
+}
+
+impl Session {
+    pub fn idle(self) -> IdleHandle {
+        match self {
+            Session::Secure(i) => {
+                let h = i.idle();
+                IdleHandle::Secure(h)
+            }
+            Session::Insecure(i) => {
+                let h = i.idle();
+                IdleHandle::Insecure(h)
+            }
+        }
+    }
+}
+
 impl Imap {
     pub fn can_idle(&self) -> bool {
-        self.config.can_idle
+        task::block_on(async move { self.config.read().await.can_idle })
     }
 
-    pub async fn idle(&mut self, context: &Context, watch_folder: Option<String>) -> Result<bool> {
-        use futures::future::FutureExt;
-
-        if !self.can_idle() {
-            return Err(Error::IdleAbilityMissing);
-        }
-        self.setup_handle_if_needed(context).await?;
-
-        self.select_folder(context, watch_folder.clone()).await?;
-
-        let session = self.session.take();
-        let timeout = Duration::from_secs(23 * 60);
-        let mut probe_network = false;
-
-        if let Some(session) = session {
-            let mut handle = session.idle();
-            if let Err(err) = handle.init().await {
-                return Err(Error::IdleProtocolFailed(err));
+    pub fn idle(&self, context: &Context, watch_folder: Option<String>) -> Result<()> {
+        task::block_on(async move {
+            if !self.can_idle() {
+                return Err(Error::IdleAbilityMissing);
             }
 
-            let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
+            self.setup_handle_if_needed(context).await?;
 
-            enum Event {
-                IdleResponse(IdleResponse),
-                Interrupt(bool),
-            }
+            self.select_folder(context, watch_folder.clone()).await?;
 
-            if self.skip_next_idle_wait {
-                // interrupt_idle has happened before we
-                // provided self.interrupt
-                self.skip_next_idle_wait = false;
-                drop(idle_wait);
-                drop(interrupt);
+            let session = self.session.lock().await.take();
+            let timeout = Duration::from_secs(23 * 60);
+            if let Some(session) = session {
+                match session.idle() {
+                    // BEWARE: If you change the Secure branch you
+                    // typically also need to change the Insecure branch.
+                    IdleHandle::Secure(mut handle) => {
+                        handle.init().await?;
 
-                info!(context, "Idle wait was skipped");
-            } else {
-                info!(context, "Idle entering wait-on-remote state");
-                let fut = idle_wait.map(|ev| ev.map(Event::IdleResponse)).race(
-                    self.idle_interrupt.recv().map(|probe_network| {
-                        Ok(Event::Interrupt(probe_network.unwrap_or_default()))
-                    }),
-                );
+                        let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
+                        *self.interrupt.lock().await = Some(interrupt);
 
-                match fut.await {
-                    Ok(Event::IdleResponse(IdleResponse::NewData(_))) => {
-                        info!(context, "Idle has NewData");
-                    }
-                    // TODO: idle_wait does not distinguish manual interrupts
-                    // from Timeouts if we would know it's a Timeout we could bail
-                    // directly and reconnect .
-                    Ok(Event::IdleResponse(IdleResponse::Timeout)) => {
-                        info!(context, "Idle-wait timeout or interruption");
-                    }
-                    Ok(Event::IdleResponse(IdleResponse::ManualInterrupt)) => {
-                        info!(context, "Idle wait was interrupted");
-                    }
-                    Ok(Event::Interrupt(probe)) => {
-                        probe_network = probe;
-                        info!(context, "Idle wait was interrupted");
-                    }
-                    Err(err) => {
-                        warn!(context, "Idle wait errored: {:?}", err);
-                    }
-                }
-            }
-
-            // if we can't properly terminate the idle
-            // protocol let's break the connection.
-            let res = handle
-                .done()
-                .timeout(Duration::from_secs(15))
-                .await
-                .map_err(|err| {
-                    self.trigger_reconnect();
-                    Error::IdleTimeout(err)
-                })?;
-
-            match res {
-                Ok(session) => {
-                    self.session = Some(Session { inner: session });
-                }
-                Err(err) => {
-                    // if we cannot terminate IDLE it probably
-                    // means that we waited long (with idle_wait)
-                    // but the network went away/changed
-                    self.trigger_reconnect();
-                    return Err(Error::IdleProtocolFailed(err));
-                }
-            }
-        }
-
-        Ok(probe_network)
-    }
-
-    pub(crate) async fn fake_idle(
-        &mut self,
-        context: &Context,
-        watch_folder: Option<String>,
-    ) -> bool {
-        // Idle using polling. This is also needed if we're not yet configured -
-        // in this case, we're waiting for a configure job (and an interrupt).
-
-        let fake_idle_start_time = SystemTime::now();
-        info!(context, "IMAP-fake-IDLEing...");
-
-        // Do not poll, just wait for an interrupt when no folder is passed in.
-        if watch_folder.is_none() {
-            return self.idle_interrupt.recv().await.unwrap_or_default();
-        }
-
-        let mut probe_network = false;
-        if self.skip_next_idle_wait {
-            // interrupt_idle has happened before we
-            // provided self.interrupt
-            self.skip_next_idle_wait = false;
-            info!(context, "fake-idle wait was skipped");
-        } else {
-            // 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));
-
-            enum Event {
-                Tick,
-                Interrupt(bool),
-            }
-            // loop until we are interrupted or if we fetched something
-            probe_network =
-                loop {
-                    use futures::future::FutureExt;
-                    match interval
-                        .next()
-                        .map(|_| Event::Tick)
-                        .race(self.idle_interrupt.recv().map(|probe_network| {
-                            Event::Interrupt(probe_network.unwrap_or_default())
-                        }))
-                        .await
-                    {
-                        Event::Tick => {
-                            // try to connect with proper login params
-                            // (setup_handle_if_needed might not know about them if we
-                            // never successfully connected)
-                            if let Err(err) = self.connect_configured(context).await {
-                                warn!(context, "fake_idle: could not connect: {}", err);
-                                continue;
-                            }
-                            if self.config.can_idle {
-                                // we only fake-idled because network was gone during IDLE, probably
-                                break false;
-                            }
-                            info!(context, "fake_idle is connected");
-                            // we are connected, let's see if fetching messages results
-                            // in anything.  If so, we behave as if IDLE had data but
-                            // will have already fetched the messages so perform_*_fetch
-                            // will not find any new.
-
-                            if let Some(ref watch_folder) = watch_folder {
-                                match self.fetch_new_messages(context, watch_folder).await {
-                                    Ok(res) => {
-                                        info!(context, "fetch_new_messages returned {:?}", res);
-                                        if res {
-                                            break false;
-                                        }
-                                    }
-                                    Err(err) => {
-                                        error!(context, "could not fetch from folder: {}", err);
-                                        self.trigger_reconnect()
-                                    }
+                        if self.skip_next_idle_wait.load(Ordering::SeqCst) {
+                            // interrupt_idle has happened before we
+                            // provided self.interrupt
+                            self.skip_next_idle_wait.store(false, Ordering::SeqCst);
+                            std::mem::drop(idle_wait);
+                            info!(context, "Idle wait was skipped");
+                        } else {
+                            info!(context, "Idle entering wait-on-remote state");
+                            match idle_wait.await {
+                                Ok(IdleResponse::NewData(_)) => {
+                                    info!(context, "Idle has NewData");
+                                }
+                                // TODO: idle_wait does not distinguish manual interrupts
+                                // from Timeouts if we would know it's a Timeout we could bail
+                                // directly and reconnect .
+                                Ok(IdleResponse::Timeout) => {
+                                    info!(context, "Idle-wait timeout or interruption");
+                                }
+                                Ok(IdleResponse::ManualInterrupt) => {
+                                    info!(context, "Idle wait was interrupted");
+                                }
+                                Err(err) => {
+                                    warn!(context, "Idle wait errored: {:?}", err);
                                 }
                             }
                         }
-                        Event::Interrupt(probe_network) => {
-                            // Interrupt
-                            break probe_network;
+                        // if we can't properly terminate the idle
+                        // protocol let's break the connection.
+                        let res =
+                            async_std::future::timeout(Duration::from_secs(15), handle.done())
+                                .await
+                                .map_err(|err| {
+                                    self.trigger_reconnect();
+                                    Error::IdleTimeout(err)
+                                })?;
+
+                        match res {
+                            Ok(session) => {
+                                *self.session.lock().await = Some(Session::Secure(session));
+                            }
+                            Err(err) => {
+                                // if we cannot terminate IDLE it probably
+                                // means that we waited long (with idle_wait)
+                                // but the network went away/changed
+                                self.trigger_reconnect();
+                                return Err(Error::IdleProtocolFailed(err));
+                            }
                         }
                     }
-                };
-        }
+                    IdleHandle::Insecure(mut handle) => {
+                        handle.init().await?;
 
-        info!(
-            context,
-            "IMAP-fake-IDLE done after {:.4}s",
-            SystemTime::now()
-                .duration_since(fake_idle_start_time)
-                .unwrap_or_default()
-                .as_millis() as f64
-                / 1000.,
-        );
+                        let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
+                        *self.interrupt.lock().await = Some(interrupt);
 
-        probe_network
+                        if self.skip_next_idle_wait.load(Ordering::SeqCst) {
+                            // interrupt_idle has happened before we
+                            // provided self.interrupt
+                            self.skip_next_idle_wait.store(false, Ordering::SeqCst);
+                            std::mem::drop(idle_wait);
+                            info!(context, "Idle wait was skipped");
+                        } else {
+                            info!(context, "Idle entering wait-on-remote state");
+                            match idle_wait.await {
+                                Ok(IdleResponse::NewData(_)) => {
+                                    info!(context, "Idle has NewData");
+                                }
+                                // TODO: idle_wait does not distinguish manual interrupts
+                                // from Timeouts if we would know it's a Timeout we could bail
+                                // directly and reconnect .
+                                Ok(IdleResponse::Timeout) => {
+                                    info!(context, "Idle-wait timeout or interruption");
+                                }
+                                Ok(IdleResponse::ManualInterrupt) => {
+                                    info!(context, "Idle wait was interrupted");
+                                }
+                                Err(err) => {
+                                    warn!(context, "Idle wait errored: {:?}", err);
+                                }
+                            }
+                        }
+                        // if we can't properly terminate the idle
+                        // protocol let's break the connection.
+                        let res =
+                            async_std::future::timeout(Duration::from_secs(15), handle.done())
+                                .await
+                                .map_err(|err| {
+                                    self.trigger_reconnect();
+                                    Error::IdleTimeout(err)
+                                })?;
+
+                        match res {
+                            Ok(session) => {
+                                *self.session.lock().await = Some(Session::Insecure(session));
+                            }
+                            Err(err) => {
+                                // if we cannot terminate IDLE it probably
+                                // means that we waited long (with idle_wait)
+                                // but the network went away/changed
+                                self.trigger_reconnect();
+                                return Err(Error::IdleProtocolFailed(err));
+                            }
+                        }
+                    }
+                }
+            }
+
+            Ok(())
+        })
+    }
+
+    pub(crate) fn fake_idle(&self, context: &Context, watch_folder: Option<String>) {
+        // Idle using polling. This is also needed if we're not yet configured -
+        // in this case, we're waiting for a configure job (and an interrupt).
+        task::block_on(async move {
+            let fake_idle_start_time = SystemTime::now();
+
+            info!(context, "IMAP-fake-IDLEing...");
+
+            let interrupt = stop_token::StopSource::new();
+
+            // check every minute if there are new messages
+            // TODO: grow sleep durations / make them more flexible
+            let interval = async_std::stream::interval(Duration::from_secs(60));
+            let mut interrupt_interval = interrupt.stop_token().stop_stream(interval);
+            *self.interrupt.lock().await = Some(interrupt);
+            if self.skip_next_idle_wait.load(Ordering::SeqCst) {
+                // interrupt_idle has happened before we
+                // provided self.interrupt
+                self.skip_next_idle_wait.store(false, Ordering::SeqCst);
+                info!(context, "fake-idle wait was skipped");
+            } else {
+                // loop until we are interrupted or if we fetched something
+                while let Some(_) = interrupt_interval.next().await {
+                    // try to connect with proper login params
+                    // (setup_handle_if_needed might not know about them if we
+                    // never successfully connected)
+                    if let Err(err) = self.connect_configured(context) {
+                        warn!(context, "fake_idle: could not connect: {}", err);
+                        continue;
+                    }
+                    if self.config.read().await.can_idle {
+                        // we only fake-idled because network was gone during IDLE, probably
+                        break;
+                    }
+                    info!(context, "fake_idle is connected");
+                    // we are connected, let's see if fetching messages results
+                    // in anything.  If so, we behave as if IDLE had data but
+                    // will have already fetched the messages so perform_*_fetch
+                    // will not find any new.
+
+                    if let Some(ref watch_folder) = watch_folder {
+                        match self.fetch_new_messages(context, watch_folder).await {
+                            Ok(res) => {
+                                info!(context, "fetch_new_messages returned {:?}", res);
+                                if res {
+                                    break;
+                                }
+                            }
+                            Err(err) => {
+                                error!(context, "could not fetch from folder: {}", err);
+                                self.trigger_reconnect()
+                            }
+                        }
+                    }
+                }
+            }
+            self.interrupt.lock().await.take();
+
+            info!(
+                context,
+                "IMAP-fake-IDLE done after {:.4}s",
+                SystemTime::now()
+                    .duration_since(fake_idle_start_time)
+                    .unwrap_or_default()
+                    .as_millis() as f64
+                    / 1000.,
+            );
+        })
+    }
+
+    pub fn interrupt_idle(&self, context: &Context) {
+        task::block_on(async move {
+            let mut interrupt: Option<stop_token::StopSource> = self.interrupt.lock().await.take();
+            if interrupt.is_none() {
+                // idle wait is not running, signal it needs to skip
+                self.skip_next_idle_wait.store(true, Ordering::SeqCst);
+
+                // meanwhile idle-wait may have produced the StopSource
+                interrupt = self.interrupt.lock().await.take();
+            }
+            // let's manually drop the StopSource
+            if interrupt.is_some() {
+                // the imap thread provided us a stop token but might
+                // not have entered idle_wait yet, give it some time
+                // for that to happen. XXX handle this without extra wait
+                // https://github.com/deltachat/deltachat-core-rust/issues/925
+                std::thread::sleep(Duration::from_millis(200));
+                info!(context, "low-level: dropping stop-source to interrupt idle");
+                std::mem::drop(interrupt)
+            }
+        });
     }
 }

src/imap/select_folder.rs

@@ -27,11 +27,11 @@ impl Imap {
     ///
     /// CLOSE is considerably faster than an EXPUNGE, see
     /// https://tools.ietf.org/html/rfc3501#section-6.4.2
-    async fn close_folder(&mut self, context: &Context) -> Result<()> {
-        if let Some(ref folder) = self.config.selected_folder {
+    async fn close_folder(&self, context: &Context) -> Result<()> {
+        if let Some(ref folder) = self.config.read().await.selected_folder {
             info!(context, "Expunge messages in \"{}\".", folder);
 
-            if let Some(ref mut session) = self.session {
+            if let Some(ref mut session) = &mut *self.session.lock().await {
                 match session.close().await {
                     Ok(_) => {
                         info!(context, "close/expunge succeeded");
@@ -45,45 +45,40 @@ impl Imap {
                 return Err(Error::NoSession);
             }
         }
-        self.config.selected_folder = None;
-        self.config.selected_folder_needs_expunge = false;
-
+        let mut cfg = self.config.write().await;
+        cfg.selected_folder = None;
+        cfg.selected_folder_needs_expunge = false;
         Ok(())
     }
 
     /// select a folder, possibly update uid_validity and, if needed,
     /// expunge the folder to remove delete-marked messages.
     pub(super) async fn select_folder<S: AsRef<str>>(
-        &mut self,
+        &self,
         context: &Context,
         folder: Option<S>,
     ) -> Result<()> {
-        if self.session.is_none() {
-            self.config.selected_folder = None;
-            self.config.selected_folder_needs_expunge = false;
+        if self.session.lock().await.is_none() {
+            let mut cfg = self.config.write().await;
+            cfg.selected_folder = None;
+            cfg.selected_folder_needs_expunge = false;
             self.trigger_reconnect();
             return Err(Error::NoSession);
         }
 
-        // if there is a new folder and the new folder is equal to the selected one, there's nothing to do.
-        // if there is _no_ new folder, we continue as we might want to expunge below.
-        if let Some(ref folder) = folder {
-            if let Some(ref selected_folder) = self.config.selected_folder {
-                if folder.as_ref() == selected_folder {
-                    return Ok(());
-                }
-            }
-        }
-
-        // deselect existing folder, if needed (it's also done implicitly by SELECT, however, without EXPUNGE then)
-        let needs_expunge = { self.config.selected_folder_needs_expunge };
+        let needs_expunge = self.config.read().await.selected_folder_needs_expunge;
         if needs_expunge {
             self.close_folder(context).await?;
         }
 
+        let folder_str: Option<&str> = folder.as_ref().map(|x| x.as_ref());
+        if self.config.read().await.selected_folder.as_deref() == folder_str {
+            return Ok(());
+        }
+
         // select new folder
         if let Some(ref folder) = folder {
-            if let Some(ref mut session) = &mut self.session {
+            if let Some(ref mut session) = &mut *self.session.lock().await {
                 let res = session.select(folder).await;
 
                 // https://tools.ietf.org/html/rfc3501#section-6.3.1
@@ -92,20 +87,21 @@ impl Imap {
 
                 match res {
                     Ok(mailbox) => {
-                        self.config.selected_folder = Some(folder.as_ref().to_string());
-                        self.config.selected_mailbox = Some(mailbox);
+                        let mut config = self.config.write().await;
+                        config.selected_folder = Some(folder.as_ref().to_string());
+                        config.selected_mailbox = Some(mailbox);
                         Ok(())
                     }
                     Err(async_imap::error::Error::ConnectionLost) => {
                         self.trigger_reconnect();
-                        self.config.selected_folder = None;
+                        self.config.write().await.selected_folder = None;
                         Err(Error::ConnectionLost)
                     }
                     Err(async_imap::error::Error::Validate(_)) => {
                         Err(Error::BadFolderName(folder.as_ref().to_string()))
                     }
                     Err(err) => {
-                        self.config.selected_folder = None;
+                        self.config.write().await.selected_folder = None;
                         self.trigger_reconnect();
                         Err(Error::Other(err.to_string()))
                     }

src/imap/session.rs

@@ -1,40 +1,172 @@
-use std::ops::{Deref, DerefMut};
-
-use async_imap::Session as ImapSession;
+use async_imap::{
+    error::Result as ImapResult,
+    types::{Capabilities, Fetch, Mailbox, Name},
+    Session as ImapSession,
+};
 use async_native_tls::TlsStream;
 use async_std::net::TcpStream;
+use async_std::prelude::*;
 
 #[derive(Debug)]
-pub(crate) struct Session {
-    pub(super) inner: ImapSession<Box<dyn SessionStream>>,
-}
-
-pub(crate) trait SessionStream:
-    async_std::io::Read + async_std::io::Write + Unpin + Send + Sync + std::fmt::Debug
-{
-}
-
-impl SessionStream for TlsStream<Box<dyn SessionStream>> {}
-impl SessionStream for TlsStream<TcpStream> {}
-impl SessionStream for TcpStream {}
-
-impl Deref for Session {
-    type Target = ImapSession<Box<dyn SessionStream>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl DerefMut for Session {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
+pub(crate) enum Session {
+    Secure(ImapSession<TlsStream<TcpStream>>),
+    Insecure(ImapSession<TcpStream>),
 }
 
 impl Session {
-    pub fn idle(self) -> async_imap::extensions::idle::Handle<Box<dyn SessionStream>> {
-        let Session { inner } = self;
-        inner.idle()
+    pub async fn capabilities(&mut self) -> ImapResult<Capabilities> {
+        let res = match self {
+            Session::Secure(i) => i.capabilities().await?,
+            Session::Insecure(i) => i.capabilities().await?,
+        };
+
+        Ok(res)
+    }
+
+    pub async fn list(
+        &mut self,
+        reference_name: Option<&str>,
+        mailbox_pattern: Option<&str>,
+    ) -> ImapResult<Vec<Name>> {
+        let res = match self {
+            Session::Secure(i) => {
+                i.list(reference_name, mailbox_pattern)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.list(reference_name, mailbox_pattern)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+        Ok(res)
+    }
+
+    pub async fn create<S: AsRef<str>>(&mut self, mailbox_name: S) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.create(mailbox_name).await?,
+            Session::Insecure(i) => i.create(mailbox_name).await?,
+        }
+        Ok(())
+    }
+
+    pub async fn subscribe<S: AsRef<str>>(&mut self, mailbox: S) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.subscribe(mailbox).await?,
+            Session::Insecure(i) => i.subscribe(mailbox).await?,
+        }
+        Ok(())
+    }
+
+    pub async fn close(&mut self) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.close().await?,
+            Session::Insecure(i) => i.close().await?,
+        }
+        Ok(())
+    }
+
+    pub async fn select<S: AsRef<str>>(&mut self, mailbox_name: S) -> ImapResult<Mailbox> {
+        let mbox = match self {
+            Session::Secure(i) => i.select(mailbox_name).await?,
+            Session::Insecure(i) => i.select(mailbox_name).await?,
+        };
+
+        Ok(mbox)
+    }
+
+    pub async fn fetch<S1, S2>(&mut self, sequence_set: S1, query: S2) -> ImapResult<Vec<Fetch>>
+    where
+        S1: AsRef<str>,
+        S2: AsRef<str>,
+    {
+        let res = match self {
+            Session::Secure(i) => {
+                i.fetch(sequence_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.fetch(sequence_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+        Ok(res)
+    }
+
+    pub async fn uid_fetch<S1, S2>(&mut self, uid_set: S1, query: S2) -> ImapResult<Vec<Fetch>>
+    where
+        S1: AsRef<str>,
+        S2: AsRef<str>,
+    {
+        let res = match self {
+            Session::Secure(i) => {
+                i.uid_fetch(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.uid_fetch(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+
+        Ok(res)
+    }
+
+    pub async fn uid_store<S1, S2>(&mut self, uid_set: S1, query: S2) -> ImapResult<Vec<Fetch>>
+    where
+        S1: AsRef<str>,
+        S2: AsRef<str>,
+    {
+        let res = match self {
+            Session::Secure(i) => {
+                i.uid_store(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.uid_store(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+        Ok(res)
+    }
+
+    pub async fn uid_mv<S1: AsRef<str>, S2: AsRef<str>>(
+        &mut self,
+        uid_set: S1,
+        mailbox_name: S2,
+    ) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.uid_mv(uid_set, mailbox_name).await?,
+            Session::Insecure(i) => i.uid_mv(uid_set, mailbox_name).await?,
+        }
+        Ok(())
+    }
+
+    pub async fn uid_copy<S1: AsRef<str>, S2: AsRef<str>>(
+        &mut self,
+        uid_set: S1,
+        mailbox_name: S2,
+    ) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.uid_copy(uid_set, mailbox_name).await?,
+            Session::Insecure(i) => i.uid_copy(uid_set, mailbox_name).await?,
+        }
+
+        Ok(())
     }
 }

src/imex.rs

@@ -1,10 +1,9 @@
 //! # Import/export module
 
-use std::any::Any;
-use std::cmp::{max, min};
+use core::cmp::{max, min};
+use std::path::Path;
 
-use async_std::path::{Path, PathBuf};
-use async_std::prelude::*;
+use num_traits::FromPrimitive;
 use rand::{thread_rng, Rng};
 
 use crate::blob::BlobObject;
@@ -17,7 +16,8 @@ use crate::dc_tools::*;
 use crate::e2ee;
 use crate::error::*;
 use crate::events::Event;
-use crate::key::{self, DcKey, DcSecretKey, SignedPublicKey, SignedSecretKey};
+use crate::job::*;
+use crate::key::{self, DcKey, Key, SignedSecretKey};
 use crate::message::{Message, MsgId};
 use crate::mimeparser::SystemMessage;
 use crate::param::*;
@@ -53,10 +53,13 @@ pub enum ImexMode {
 }
 
 /// Import/export things.
+/// For this purpose, the function creates a job that is executed in the IMAP-thread then;
+/// this requires to call dc_perform_inbox_jobs() regularly.
 ///
 /// What to do is defined by the *what* parameter.
 ///
-/// During execution of the job,
+/// While dc_imex() returns immediately, the started job may take a while,
+/// you can stop it using dc_stop_ongoing_process(). During execution of the job,
 /// some events are sent out:
 ///
 /// - A number of #DC_EVENT_IMEX_PROGRESS events are sent and may be used to create
@@ -65,48 +68,41 @@ pub enum ImexMode {
 /// - For each file written on export, the function sends #DC_EVENT_IMEX_FILE_WRITTEN
 ///
 /// Only one import-/export-progress can run at the same time.
-/// To cancel an import-/export-progress, drop the future returned by this function.
-pub async fn imex(
-    context: &Context,
-    what: ImexMode,
-    param1: Option<impl AsRef<Path>>,
-) -> Result<()> {
-    use futures::future::FutureExt;
+/// To cancel an import-/export-progress, use dc_stop_ongoing_process().
+pub fn imex(context: &Context, what: ImexMode, param1: Option<impl AsRef<Path>>) {
+    let mut param = Params::new();
+    param.set_int(Param::Cmd, what as i32);
+    if let Some(param1) = param1 {
+        param.set(Param::Arg, param1.as_ref().to_string_lossy());
+    }
 
-    let cancel = context.alloc_ongoing().await?;
-    let res = imex_inner(context, what, param1)
-        .race(cancel.recv().map(|_| Err(format_err!("canceled"))))
-        .await;
-
-    context.free_ongoing().await;
-
-    res
+    job_kill_action(context, Action::ImexImap);
+    job_add(context, Action::ImexImap, 0, param, 0);
 }
 
 /// Returns the filename of the backup found (otherwise an error)
-pub async fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<String> {
+pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<String> {
     let dir_name = dir_name.as_ref();
-    let mut dir_iter = async_std::fs::read_dir(dir_name).await?;
+    let dir_iter = std::fs::read_dir(dir_name)?;
     let mut newest_backup_time = 0;
-    let mut newest_backup_path: Option<PathBuf> = None;
-    while let Some(dirent) = dir_iter.next().await {
+    let mut newest_backup_path: Option<std::path::PathBuf> = None;
+    for dirent in dir_iter {
         if let Ok(dirent) = dirent {
             let path = dirent.path();
             let name = dirent.file_name();
             let name = name.to_string_lossy();
             if name.starts_with("delta-chat") && name.ends_with(".bak") {
                 let sql = Sql::new();
-                if sql.open(context, &path, true).await {
+                if sql.open(context, &path, true) {
                     let curr_backup_time = sql
                         .get_raw_config_int(context, "backup_time")
-                        .await
                         .unwrap_or_default();
                     if curr_backup_time > newest_backup_time {
                         newest_backup_path = Some(path);
                         newest_backup_time = curr_backup_time;
                     }
                     info!(context, "backup_time of {} is {}", name, curr_backup_time);
-                    sql.close().await;
+                    sql.close(&context);
                 }
             }
         }
@@ -117,32 +113,28 @@ pub async fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result
     }
 }
 
-pub async fn initiate_key_transfer(context: &Context) -> Result<String> {
-    use futures::future::FutureExt;
-
-    let cancel = context.alloc_ongoing().await?;
-    let res = do_initiate_key_transfer(context)
-        .race(cancel.recv().map(|_| Err(format_err!("canceled"))))
-        .await;
-
-    context.free_ongoing().await;
+pub fn initiate_key_transfer(context: &Context) -> Result<String> {
+    ensure!(context.alloc_ongoing(), "could not allocate ongoing");
+    let res = do_initiate_key_transfer(context);
+    context.free_ongoing();
     res
 }
 
-async fn do_initiate_key_transfer(context: &Context) -> Result<String> {
+fn do_initiate_key_transfer(context: &Context) -> Result<String> {
     let mut msg: Message;
     let setup_code = create_setup_code(context);
     /* this may require a keypair to be created. this may take a second ... */
-    let setup_file_content = render_setup_file(context, &setup_code).await?;
+    ensure!(!context.shall_stop_ongoing(), "canceled");
+    let setup_file_content = render_setup_file(context, &setup_code)?;
     /* encrypting may also take a while ... */
+    ensure!(!context.shall_stop_ongoing(), "canceled");
     let setup_file_blob = BlobObject::create(
         context,
         "autocrypt-setup-message.html",
         setup_file_content.as_bytes(),
-    )
-    .await?;
+    )?;
 
-    let chat_id = chat::create_by_contact_id(context, DC_CONTACT_ID_SELF).await?;
+    let chat_id = chat::create_by_contact_id(context, DC_CONTACT_ID_SELF)?;
     msg = Message::default();
     msg.viewtype = Viewtype::File;
     msg.param.set(Param::File, setup_file_blob.as_name());
@@ -155,11 +147,12 @@ async fn do_initiate_key_transfer(context: &Context) -> Result<String> {
         ForcePlaintext::NoAutocryptHeader as i32,
     );
 
-    let msg_id = chat::send_msg(context, chat_id, &mut msg).await?;
+    ensure!(!context.shall_stop_ongoing(), "canceled");
+    let msg_id = chat::send_msg(context, chat_id, &mut msg)?;
     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;
-        if let Ok(msg) = Message::load_from_db(context, msg_id).await {
+    while !context.shall_stop_ongoing() {
+        std::thread::sleep(std::time::Duration::from_secs(1));
+        if let Ok(msg) = Message::load_from_db(context, msg_id) {
             if msg.is_sent() {
                 info!(context, "... setup message sent.",);
                 break;
@@ -177,18 +170,18 @@ async fn do_initiate_key_transfer(context: &Context) -> Result<String> {
 /// Renders HTML body of a setup file message.
 ///
 /// The `passphrase` must be at least 2 characters long.
-pub async fn render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
+pub fn render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
     ensure!(
         passphrase.len() >= 2,
         "Passphrase must be at least 2 chars long."
     );
-    let private_key = SignedSecretKey::load_self(context).await?;
-    let ac_headers = match context.get_config_bool(Config::E2eeEnabled).await {
+    let private_key = Key::from(SignedSecretKey::load_self(context)?);
+    let ac_headers = match context.get_config_bool(Config::E2eeEnabled) {
         false => None,
         true => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
     };
     let private_key_asc = private_key.to_asc(ac_headers);
-    let encr = pgp::symm_encrypt(&passphrase, private_key_asc.as_bytes()).await?;
+    let encr = pgp::symm_encrypt(&passphrase, private_key_asc.as_bytes())?;
 
     let replacement = format!(
         concat!(
@@ -200,8 +193,8 @@ pub async fn render_setup_file(context: &Context, passphrase: &str) -> Result<St
     );
     let pgp_msg = encr.replace("-----BEGIN PGP MESSAGE-----", &replacement);
 
-    let msg_subj = context.stock_str(StockMessage::AcSetupMsgSubject).await;
-    let msg_body = context.stock_str(StockMessage::AcSetupMsgBody).await;
+    let msg_subj = context.stock_str(StockMessage::AcSetupMsgSubject);
+    let msg_body = context.stock_str(StockMessage::AcSetupMsgBody);
     let msg_body_html = msg_body.replace("\r", "").replace("\n", "<br>");
     Ok(format!(
         concat!(
@@ -244,8 +237,8 @@ pub fn create_setup_code(_context: &Context) -> String {
     ret
 }
 
-async fn maybe_add_bcc_self_device_msg(context: &Context) -> Result<()> {
-    if !context.sql.get_raw_config_bool(context, "bcc_self").await {
+fn maybe_add_bcc_self_device_msg(context: &Context) -> Result<()> {
+    if !context.sql.get_raw_config_bool(context, "bcc_self") {
         let mut msg = Message::new(Viewtype::Text);
         // TODO: define this as a stockstring once the wording is settled.
         msg.text = Some(
@@ -254,30 +247,26 @@ async fn maybe_add_bcc_self_device_msg(context: &Context) -> Result<()> {
              go to the settings and enable \"Send copy to self\"."
                 .to_string(),
         );
-        chat::add_device_msg(context, Some("bcc-self-hint"), Some(&mut msg)).await?;
+        chat::add_device_msg(context, Some("bcc-self-hint"), Some(&mut msg))?;
     }
     Ok(())
 }
 
-pub async fn continue_key_transfer(
-    context: &Context,
-    msg_id: MsgId,
-    setup_code: &str,
-) -> Result<()> {
+pub fn continue_key_transfer(context: &Context, msg_id: MsgId, setup_code: &str) -> Result<()> {
     ensure!(!msg_id.is_special(), "wrong id");
 
-    let msg = Message::load_from_db(context, msg_id).await?;
+    let msg = Message::load_from_db(context, msg_id)?;
     ensure!(
         msg.is_setupmessage(),
         "Message is no Autocrypt Setup Message."
     );
 
     if let Some(filename) = msg.get_file(context) {
-        let file = dc_open_file_std(context, filename)?;
+        let file = dc_open_file(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?;
-        maybe_add_bcc_self_device_msg(context).await?;
+        let armored_key = decrypt_setup_file(context, &sc, file)?;
+        set_self_key(context, &armored_key, true, true)?;
+        maybe_add_bcc_self_device_msg(context)?;
 
         Ok(())
     } else {
@@ -285,15 +274,19 @@ pub async fn continue_key_transfer(
     }
 }
 
-async fn set_self_key(
+fn set_self_key(
     context: &Context,
     armored: &str,
     set_default: bool,
     prefer_encrypt_required: bool,
 ) -> Result<()> {
     // try hard to only modify key-state
-    let (private_key, header) = SignedSecretKey::from_asc(armored)?;
-    let public_key = private_key.split_public_key()?;
+    let keys = Key::from_armored_string(armored, KeyType::Private)
+        .and_then(|(k, h)| if k.verify() { Some((k, h)) } else { None })
+        .and_then(|(k, h)| k.split_key().map(|pub_key| (k, pub_key, h)));
+
+    ensure!(keys.is_some(), "Not a valid private key");
+    let (private_key, public_key, header) = keys.unwrap();
     let preferencrypt = header.get("Autocrypt-Prefer-Encrypt");
     match preferencrypt.map(|s| s.as_str()) {
         Some(headerval) => {
@@ -306,8 +299,7 @@ async fn set_self_key(
             };
             context
                 .sql
-                .set_raw_config_int(context, "e2ee_enabled", e2ee_enabled)
-                .await?;
+                .set_raw_config_int(context, "e2ee_enabled", e2ee_enabled)?;
         }
         None => {
             if prefer_encrypt_required {
@@ -316,13 +308,18 @@ async fn set_self_key(
         }
     };
 
-    let self_addr = context.get_config(Config::ConfiguredAddr).await;
+    let self_addr = context.get_config(Config::ConfiguredAddr);
     ensure!(self_addr.is_some(), "Missing self addr");
     let addr = EmailAddress::new(&self_addr.unwrap_or_default())?;
+
+    let (public, secret) = match (public_key, private_key) {
+        (Key::Public(p), Key::Secret(s)) => (p, s),
+        _ => bail!("wrong keys unpacked"),
+    };
     let keypair = pgp::KeyPair {
         addr,
-        public: public_key,
-        secret: private_key,
+        public,
+        secret,
     };
     key::store_self_keypair(
         context,
@@ -332,16 +329,16 @@ async fn set_self_key(
         } else {
             key::KeyPairUse::ReadOnly
         },
-    )
-    .await?;
+    )?;
     Ok(())
 }
 
-async fn decrypt_setup_file<T: std::io::Read + std::io::Seek>(
+fn decrypt_setup_file<T: std::io::Read + std::io::Seek>(
+    _context: &Context,
     passphrase: &str,
     file: T,
 ) -> Result<String> {
-    let plain_bytes = pgp::symm_decrypt(passphrase, file).await?;
+    let plain_bytes = pgp::symm_decrypt(passphrase, file)?;
     let plain_text = std::string::String::from_utf8(plain_bytes)?;
 
     Ok(plain_text)
@@ -360,50 +357,52 @@ pub fn normalize_setup_code(s: &str) -> String {
     out
 }
 
-async fn imex_inner(
-    context: &Context,
-    what: ImexMode,
-    param: Option<impl AsRef<Path>>,
-) -> Result<()> {
-    ensure!(param.is_some(), "No Import/export dir/file given.");
+#[allow(non_snake_case)]
+pub fn JobImexImap(context: &Context, job: &Job) -> Result<()> {
+    ensure!(context.alloc_ongoing(), "could not allocate ongoing");
+    let what: Option<ImexMode> = job.param.get_int(Param::Cmd).and_then(ImexMode::from_i32);
+    let param = job.param.get(Param::Arg).unwrap_or_default();
 
+    ensure!(!param.is_empty(), "No Import/export dir/file given.");
     info!(context, "Import/export process started.");
-    context.emit_event(Event::ImexProgress(10));
+    context.call_cb(Event::ImexProgress(10));
 
-    ensure!(context.sql.is_open().await, "Database not opened.");
-
-    let path = param.unwrap();
-    if what == ImexMode::ExportBackup || what == ImexMode::ExportSelfKeys {
+    ensure!(context.sql.is_open(), "Database not opened.");
+    if what == Some(ImexMode::ExportBackup) || what == Some(ImexMode::ExportSelfKeys) {
         // before we export anything, make sure the private key exists
-        if e2ee::ensure_secret_key_exists(context).await.is_err() {
+        if e2ee::ensure_secret_key_exists(context).is_err() {
+            context.free_ongoing();
             bail!("Cannot create private key or private key not available.");
         } else {
-            dc_create_folder(context, &path).await?;
+            dc_create_folder(context, &param)?;
         }
     }
-
+    let path = Path::new(param);
     let success = match what {
-        ImexMode::ExportSelfKeys => export_self_keys(context, path).await,
-        ImexMode::ImportSelfKeys => import_self_keys(context, path).await,
-        ImexMode::ExportBackup => export_backup(context, path).await,
-        ImexMode::ImportBackup => import_backup(context, path).await,
+        Some(ImexMode::ExportSelfKeys) => export_self_keys(context, path),
+        Some(ImexMode::ImportSelfKeys) => import_self_keys(context, path),
+        Some(ImexMode::ExportBackup) => export_backup(context, path),
+        Some(ImexMode::ImportBackup) => import_backup(context, path),
+        None => {
+            bail!("unknown IMEX type");
+        }
     };
-
+    context.free_ongoing();
     match success {
         Ok(()) => {
             info!(context, "IMEX successfully completed");
-            context.emit_event(Event::ImexProgress(1000));
+            context.call_cb(Event::ImexProgress(1000));
             Ok(())
         }
         Err(err) => {
-            context.emit_event(Event::ImexProgress(0));
+            context.call_cb(Event::ImexProgress(0));
             bail!("IMEX FAILED to complete: {}", err);
         }
     }
 }
 
 /// Import Backup
-async fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Result<()> {
+fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Result<()> {
     info!(
         context,
         "Import \"{}\" to \"{}\".",
@@ -412,93 +411,84 @@ async fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) ->
     );
 
     ensure!(
-        !context.is_configured().await,
+        !context.is_configured(),
         "Cannot import backups to accounts in use."
     );
-    context.sql.close().await;
-    dc_delete_file(context, context.get_dbfile()).await;
+    context.sql.close(&context);
+    dc_delete_file(context, context.get_dbfile());
     ensure!(
-        !context.get_dbfile().exists().await,
+        !context.get_dbfile().exists(),
         "Cannot delete old database."
     );
 
     ensure!(
-        dc_copy_file(context, backup_to_import.as_ref(), context.get_dbfile()).await,
+        dc_copy_file(context, backup_to_import.as_ref(), context.get_dbfile()),
         "could not copy file"
     );
     /* error already logged */
     /* re-open copied database file */
     ensure!(
-        context
-            .sql
-            .open(&context, &context.get_dbfile(), false)
-            .await,
+        context.sql.open(&context, &context.get_dbfile(), false),
         "could not re-open db"
     );
 
-    delete_and_reset_all_device_msgs(&context).await?;
+    delete_and_reset_all_device_msgs(&context)?;
 
     let total_files_cnt = context
         .sql
-        .query_get_value::<isize>(context, "SELECT COUNT(*) FROM backup_blobs;", paramsv![])
-        .await
+        .query_get_value::<_, isize>(context, "SELECT COUNT(*) FROM backup_blobs;", params![])
         .unwrap_or_default() as usize;
     info!(
         context,
         "***IMPORT-in-progress: total_files_cnt={:?}", total_files_cnt,
     );
 
-    let files = context
-        .sql
-        .query_map(
-            "SELECT file_name, file_content FROM backup_blobs ORDER BY id;",
-            paramsv![],
-            |row| {
-                let name: String = row.get(0)?;
-                let blob: Vec<u8> = row.get(1)?;
+    let res = context.sql.query_map(
+        "SELECT file_name, file_content FROM backup_blobs ORDER BY id;",
+        params![],
+        |row| {
+            let name: String = row.get(0)?;
+            let blob: Vec<u8> = row.get(1)?;
 
-                Ok((name, blob))
-            },
-            |files| {
-                files
-                    .collect::<std::result::Result<Vec<_>, _>>()
-                    .map_err(Into::into)
-            },
-        )
-        .await?;
+            Ok((name, blob))
+        },
+        |files| {
+            for (processed_files_cnt, file) in files.enumerate() {
+                let (file_name, file_blob) = file?;
+                if context.shall_stop_ongoing() {
+                    return Ok(false);
+                }
+                let mut permille = processed_files_cnt * 1000 / total_files_cnt;
+                if permille < 10 {
+                    permille = 10
+                }
+                if permille > 990 {
+                    permille = 990
+                }
+                context.call_cb(Event::ImexProgress(permille));
+                if file_blob.is_empty() {
+                    continue;
+                }
 
-    let mut all_files_extracted = true;
-    for (processed_files_cnt, (file_name, file_blob)) in files.into_iter().enumerate() {
-        if context.shall_stop_ongoing().await {
-            all_files_extracted = false;
-            break;
-        }
-        let mut permille = processed_files_cnt * 1000 / total_files_cnt;
-        if permille < 10 {
-            permille = 10
-        }
-        if permille > 990 {
-            permille = 990
-        }
-        context.emit_event(Event::ImexProgress(permille));
-        if file_blob.is_empty() {
-            continue;
-        }
+                let path_filename = context.get_blobdir().join(file_name);
+                dc_write_file(context, &path_filename, &file_blob)?;
+            }
+            Ok(true)
+        },
+    );
 
-        let path_filename = context.get_blobdir().join(file_name);
-        dc_write_file(context, &path_filename, &file_blob).await?;
-    }
-
-    if all_files_extracted {
-        // only delete backup_blobs if all files were successfully extracted
-        context
-            .sql
-            .execute("DROP TABLE backup_blobs;", paramsv![])
-            .await?;
-        context.sql.execute("VACUUM;", paramsv![]).await.ok();
-        Ok(())
-    } else {
-        bail!("received stop signal");
+    match res {
+        Ok(all_files_extracted) => {
+            if all_files_extracted {
+                // only delete backup_blobs if all files were successfully extracted
+                sql::execute(context, &context.sql, "DROP TABLE backup_blobs;", params![])?;
+                sql::try_execute(context, &context.sql, "VACUUM;").ok();
+                Ok(())
+            } else {
+                bail!("received stop signal");
+            }
+        }
+        Err(err) => Err(err.into()),
     }
 }
 
@@ -507,31 +497,28 @@ async fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) ->
  ******************************************************************************/
 /* the FILE_PROGRESS macro calls the callback with the permille of files processed.
 The macro avoids weird values of 0% or 100% while still working. */
-async fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
+fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
     // FIXME: we should write to a temporary file first and rename it on success. this would guarantee the backup is complete.
     // let dest_path_filename = dc_get_next_backup_file(context, dir, res);
     let now = time();
-    let dest_path_filename = dc_get_next_backup_path(dir, now).await?;
+    let dest_path_filename = dc_get_next_backup_path(dir, now)?;
     let dest_path_string = dest_path_filename.to_string_lossy().to_string();
 
-    sql::housekeeping(context).await;
+    sql::housekeeping(context);
 
-    context.sql.execute("VACUUM;", paramsv![]).await.ok();
+    sql::try_execute(context, &context.sql, "VACUUM;").ok();
 
     // we close the database during the copy of the dbfile
-    context.sql.close().await;
+    context.sql.close(context);
     info!(
         context,
         "Backup '{}' to '{}'.",
         context.get_dbfile().display(),
         dest_path_filename.display(),
     );
-    let copied = dc_copy_file(context, context.get_dbfile(), &dest_path_filename).await;
-    context
-        .sql
-        .open(&context, &context.get_dbfile(), false)
-        .await;
+    let copied = dc_copy_file(context, context.get_dbfile(), &dest_path_filename);
+    context.sql.open(&context, &context.get_dbfile(), false);
 
     if !copied {
         bail!(
@@ -542,90 +529,86 @@ async fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     }
     let dest_sql = Sql::new();
     ensure!(
-        dest_sql.open(context, &dest_path_filename, false).await,
+        dest_sql.open(context, &dest_path_filename, false),
         "could not open exported database {}",
         dest_path_string
     );
-    let res = match add_files_to_export(context, &dest_sql).await {
+    let res = match add_files_to_export(context, &dest_sql) {
         Err(err) => {
-            dc_delete_file(context, &dest_path_filename).await;
+            dc_delete_file(context, &dest_path_filename);
             error!(context, "backup failed: {}", err);
             Err(err)
         }
         Ok(()) => {
-            dest_sql
-                .set_raw_config_int(context, "backup_time", now as i32)
-                .await?;
-            context.emit_event(Event::ImexFileWritten(dest_path_filename));
+            dest_sql.set_raw_config_int(context, "backup_time", now as i32)?;
+            context.call_cb(Event::ImexFileWritten(dest_path_filename));
             Ok(())
         }
     };
-    dest_sql.close().await;
+    dest_sql.close(context);
 
     Ok(res?)
 }
 
-async fn add_files_to_export(context: &Context, sql: &Sql) -> Result<()> {
+fn add_files_to_export(context: &Context, sql: &Sql) -> Result<()> {
     // add all files as blobs to the database copy (this does not require
     // the source to be locked, neigher the destination as it is used only here)
-    if !sql.table_exists("backup_blobs").await? {
-        sql.execute(
+    if !sql.table_exists("backup_blobs") {
+        sql::execute(
+            context,
+            &sql,
             "CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);",
-            paramsv![],
-        )
-        .await?;
+            params![],
+        )?
     }
     // copy all files from BLOBDIR into backup-db
     let mut total_files_cnt = 0;
     let dir = context.get_blobdir();
-    let dir_handle = async_std::fs::read_dir(&dir).await?;
-    total_files_cnt += dir_handle.filter(|r| r.is_ok()).count().await;
+    let dir_handle = std::fs::read_dir(&dir)?;
+    total_files_cnt += dir_handle.filter(|r| r.is_ok()).count();
 
     info!(context, "EXPORT: total_files_cnt={}", total_files_cnt);
+    // scan directory, pass 2: copy files
+    let dir_handle = std::fs::read_dir(&dir)?;
+    let exported_all_files = sql.prepare(
+        "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
+        |mut stmt, _| {
+            let mut processed_files_cnt = 0;
+            for entry in dir_handle {
+                let entry = entry?;
+                if context.shall_stop_ongoing() {
+                    return Ok(false);
+                }
+                processed_files_cnt += 1;
+                let permille = max(min(processed_files_cnt * 1000 / total_files_cnt, 990), 10);
+                context.call_cb(Event::ImexProgress(permille));
 
-    sql.with_conn_async(|conn| async move {
-        // scan directory, pass 2: copy files
-        let mut dir_handle = async_std::fs::read_dir(&dir).await?;
-
-        let mut processed_files_cnt = 0;
-        while let Some(entry) = dir_handle.next().await {
-            let entry = entry?;
-            if context.shall_stop_ongoing().await {
-                return Ok(());
-            }
-            processed_files_cnt += 1;
-            let permille = max(min(processed_files_cnt * 1000 / total_files_cnt, 990), 10);
-            context.emit_event(Event::ImexProgress(permille));
-
-            let name_f = entry.file_name();
-            let name = name_f.to_string_lossy();
-            if name.starts_with("delta-chat") && name.ends_with(".bak") {
-                continue;
-            }
-            info!(context, "EXPORT: copying filename={}", name);
-            let curr_path_filename = context.get_blobdir().join(entry.file_name());
-            if let Ok(buf) = dc_read_file(context, &curr_path_filename).await {
-                if buf.is_empty() {
+                let name_f = entry.file_name();
+                let name = name_f.to_string_lossy();
+                if name.starts_with("delta-chat") && name.ends_with(".bak") {
                     continue;
                 }
-                // bail out if we can't insert
-                let mut stmt = conn.prepare_cached(
-                    "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
-                )?;
-                stmt.execute(paramsv![name, buf])?;
+                info!(context, "EXPORT: copying filename={}", name);
+                let curr_path_filename = context.get_blobdir().join(entry.file_name());
+                if let Ok(buf) = dc_read_file(context, &curr_path_filename) {
+                    if buf.is_empty() {
+                        continue;
+                    }
+                    // bail out if we can't insert
+                    stmt.execute(params![name, buf])?;
+                }
             }
-        }
-        Ok(())
-    })
-    .await?;
-
+            Ok(true)
+        },
+    )?;
+    ensure!(exported_all_files, "canceled during export-files");
     Ok(())
 }
 
 /*******************************************************************************
  * Classic key import
  ******************************************************************************/
-async fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
+fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     /* hint: even if we switch to import Autocrypt Setup Files, we should leave the possibility to import
     plain ASC keys, at least keys without a password, if we do not want to implement a password entry function.
     Importing ASC keys is useful to use keys in Delta Chat used by any other non-Autocrypt-PGP implementation.
@@ -636,8 +619,8 @@ async fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()
     let mut imported_cnt = 0;
 
     let dir_name = dir.as_ref().to_string_lossy();
-    let mut dir_handle = async_std::fs::read_dir(&dir).await?;
-    while let Some(entry) = dir_handle.next().await {
+    let dir_handle = std::fs::read_dir(&dir)?;
+    for entry in dir_handle {
         let entry_fn = entry?.file_name();
         let name_f = entry_fn.to_string_lossy();
         let path_plus_name = dir.as_ref().join(&entry_fn);
@@ -657,10 +640,10 @@ async fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()
                 continue;
             }
         }
-        match dc_read_file(context, &path_plus_name).await {
+        match dc_read_file(context, &path_plus_name) {
             Ok(buf) => {
                 let armored = std::string::String::from_utf8_lossy(&buf);
-                if let Err(err) = set_self_key(context, &armored, set_default, false).await {
+                if let Err(err) = set_self_key(context, &armored, set_default, false) {
                     error!(context, "set_self_key: {}", err);
                     continue;
                 }
@@ -677,54 +660,45 @@ async fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()
     Ok(())
 }
 
-async fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
+fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     let mut export_errors = 0;
 
-    let keys = context
-        .sql
-        .query_map(
-            "SELECT id, public_key, private_key, is_default FROM keypairs;",
-            paramsv![],
-            |row| {
-                let id = row.get(0)?;
-                let public_key_blob: Vec<u8> = row.get(1)?;
-                let public_key = SignedPublicKey::from_slice(&public_key_blob);
-                let private_key_blob: Vec<u8> = row.get(2)?;
-                let private_key = SignedSecretKey::from_slice(&private_key_blob);
-                let is_default: i32 = row.get(3)?;
+    context.sql.query_map(
+        "SELECT id, public_key, private_key, is_default FROM keypairs;",
+        params![],
+        |row| {
+            let id = row.get(0)?;
+            let public_key_blob: Vec<u8> = row.get(1)?;
+            let public_key = Key::from_slice(&public_key_blob, KeyType::Public);
+            let private_key_blob: Vec<u8> = row.get(2)?;
+            let private_key = Key::from_slice(&private_key_blob, KeyType::Private);
+            let is_default: i32 = row.get(3)?;
 
-                Ok((id, public_key, private_key, is_default))
-            },
-            |keys| {
-                keys.collect::<std::result::Result<Vec<_>, _>>()
-                    .map_err(Into::into)
-            },
-        )
-        .await?;
+            Ok((id, public_key, private_key, is_default))
+        },
+        |keys| {
+            for key_pair in keys {
+                let (id, public_key, private_key, is_default) = key_pair?;
+                let id = Some(id).filter(|_| is_default != 0);
+                if let Some(key) = public_key {
+                    if export_key_to_asc_file(context, &dir, id, &key).is_err() {
+                        export_errors += 1;
+                    }
+                } else {
+                    export_errors += 1;
+                }
+                if let Some(key) = private_key {
+                    if export_key_to_asc_file(context, &dir, id, &key).is_err() {
+                        export_errors += 1;
+                    }
+                } else {
+                    export_errors += 1;
+                }
+            }
 
-    for (id, public_key, private_key, is_default) in keys {
-        let id = Some(id).filter(|_| is_default != 0);
-        if let Ok(key) = public_key {
-            if export_key_to_asc_file(context, &dir, id, &key)
-                .await
-                .is_err()
-            {
-                export_errors += 1;
-            }
-        } else {
-            export_errors += 1;
-        }
-        if let Ok(key) = private_key {
-            if export_key_to_asc_file(context, &dir, id, &key)
-                .await
-                .is_err()
-            {
-                export_errors += 1;
-            }
-        } else {
-            export_errors += 1;
-        }
-    }
+            Ok(())
+        },
+    )?;
 
     ensure!(export_errors == 0, "errors while exporting keys");
     Ok(())
@@ -733,36 +707,26 @@ async fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()
 /*******************************************************************************
  * Classic key export
  ******************************************************************************/
-async fn export_key_to_asc_file<T>(
+fn export_key_to_asc_file(
     context: &Context,
     dir: impl AsRef<Path>,
     id: Option<i64>,
-    key: &T,
-) -> std::io::Result<()>
-where
-    T: DcKey + Any,
-{
+    key: &Key,
+) -> std::io::Result<()> {
     let file_name = {
-        let any_key = key as &dyn Any;
-        let kind = if any_key.downcast_ref::<SignedPublicKey>().is_some() {
-            "public"
-        } else if any_key.downcast_ref::<SignedPublicKey>().is_some() {
-            "private"
-        } else {
-            "unknown"
-        };
+        let kind = if key.is_public() { "public" } else { "private" };
         let id = id.map_or("default".into(), |i| i.to_string());
+
         dir.as_ref().join(format!("{}-key-{}.asc", kind, &id))
     };
     info!(context, "Exporting key {}", file_name.display());
-    dc_delete_file(context, &file_name).await;
+    dc_delete_file(context, &file_name);
 
-    let content = key.to_asc(None).into_bytes();
-    let res = dc_write_file(context, &file_name, &content).await;
+    let res = key.write_asc_to_file(&file_name, context);
     if res.is_err() {
         error!(context, "Cannot write key to {}", file_name.display());
     } else {
-        context.emit_event(Event::ImexFileWritten(file_name));
+        context.call_cb(Event::ImexFileWritten(file_name));
     }
     res
 }
@@ -774,12 +738,12 @@ mod tests {
     use crate::test_utils::*;
     use ::pgp::armor::BlockType;
 
-    #[async_std::test]
-    async fn test_render_setup_file() {
-        let t = test_context().await;
+    #[test]
+    fn test_render_setup_file() {
+        let t = test_context(Some(Box::new(logging_cb)));
 
-        configure_alice_keypair(&t.ctx).await;
-        let msg = render_setup_file(&t.ctx, "hello").await.unwrap();
+        configure_alice_keypair(&t.ctx);
+        let msg = render_setup_file(&t.ctx, "hello").unwrap();
         println!("{}", &msg);
         // Check some substrings, indicating things got substituted.
         // In particular note the mixing of `\r\n` and `\n` depending
@@ -793,22 +757,21 @@ mod tests {
         assert!(msg.contains("-----END PGP MESSAGE-----\n"));
     }
 
-    #[async_std::test]
-    async fn test_render_setup_file_newline_replace() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_render_setup_file_newline_replace() {
+        let t = dummy_context();
         t.ctx
             .set_stock_translation(StockMessage::AcSetupMsgBody, "hello\r\nthere".to_string())
-            .await
             .unwrap();
-        configure_alice_keypair(&t.ctx).await;
-        let msg = render_setup_file(&t.ctx, "pw").await.unwrap();
+        configure_alice_keypair(&t.ctx);
+        let msg = render_setup_file(&t.ctx, "pw").unwrap();
         println!("{}", &msg);
         assert!(msg.contains("<p>hello<br>there</p>"));
     }
 
-    #[async_std::test]
-    async fn test_create_setup_code() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_create_setup_code() {
+        let t = dummy_context();
         let setupcode = create_setup_code(&t.ctx);
         assert_eq!(setupcode.len(), 44);
         assert_eq!(setupcode.chars().nth(4).unwrap(), '-');
@@ -821,17 +784,15 @@ mod tests {
         assert_eq!(setupcode.chars().nth(39).unwrap(), '-');
     }
 
-    #[async_std::test]
-    async fn test_export_key_to_asc_file() {
-        let context = dummy_context().await;
-        let key = alice_keypair().public;
+    #[test]
+    fn test_export_key_to_asc_file() {
+        let context = dummy_context();
+        let key = Key::from(alice_keypair().public);
         let blobdir = "$BLOBDIR";
-        assert!(export_key_to_asc_file(&context.ctx, blobdir, None, &key)
-            .await
-            .is_ok());
+        assert!(export_key_to_asc_file(&context.ctx, blobdir, None, &key).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 = std::fs::read(&filename).unwrap();
 
         assert_eq!(bytes, key.to_asc(None).into_bytes());
     }
@@ -851,8 +812,11 @@ 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]
-    async fn test_split_and_decrypt() {
+    #[test]
+    fn test_split_and_decrypt() {
+        let ctx = dummy_context();
+        let context = &ctx.ctx;
+
         let buf_1 = S_EM_SETUPFILE.as_bytes().to_vec();
         let (typ, headers, base64) = split_armored_data(&buf_1).unwrap();
         assert_eq!(typ, BlockType::Message);
@@ -862,10 +826,12 @@ mod tests {
         assert!(!base64.is_empty());
 
         let setup_file = S_EM_SETUPFILE.to_string();
-        let decrypted =
-            decrypt_setup_file(S_EM_SETUPCODE, std::io::Cursor::new(setup_file.as_bytes()))
-                .await
-                .unwrap();
+        let decrypted = decrypt_setup_file(
+            context,
+            S_EM_SETUPCODE,
+            std::io::Cursor::new(setup_file.as_bytes()),
+        )
+        .unwrap();
 
         let (typ, headers, _base64) = split_armored_data(decrypted.as_bytes()).unwrap();
 

src/job_thread.rs

@@ -0,0 +1,203 @@
+use std::sync::{Arc, Condvar, Mutex};
+
+use crate::context::Context;
+use crate::error::{format_err, Result};
+use crate::imap::Imap;
+
+#[derive(Debug)]
+pub struct JobThread {
+    pub name: &'static str,
+    pub folder_config_name: &'static str,
+    pub imap: Imap,
+    pub state: Arc<(Mutex<JobState>, Condvar)>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct JobState {
+    idle: bool,
+    jobs_needed: bool,
+    suspended: bool,
+    using_handle: bool,
+}
+
+impl JobThread {
+    pub fn new(name: &'static str, folder_config_name: &'static str, imap: Imap) -> Self {
+        JobThread {
+            name,
+            folder_config_name,
+            imap,
+            state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
+        }
+    }
+
+    pub fn suspend(&self, context: &Context) {
+        info!(context, "Suspending {}-thread.", self.name,);
+        {
+            self.state.0.lock().unwrap().suspended = true;
+        }
+        self.interrupt_idle(context);
+        loop {
+            let using_handle = self.state.0.lock().unwrap().using_handle;
+            if !using_handle {
+                return;
+            }
+            std::thread::sleep(std::time::Duration::from_micros(300 * 1000));
+        }
+    }
+
+    pub fn unsuspend(&self, context: &Context) {
+        info!(context, "Unsuspending {}-thread.", self.name);
+
+        let &(ref lock, ref cvar) = &*self.state.clone();
+        let mut state = lock.lock().unwrap();
+
+        state.suspended = false;
+        state.idle = true;
+        cvar.notify_one();
+    }
+
+    pub fn interrupt_idle(&self, context: &Context) {
+        {
+            self.state.0.lock().unwrap().jobs_needed = true;
+        }
+
+        info!(context, "Interrupting {}-IDLE...", self.name);
+
+        self.imap.interrupt_idle(context);
+
+        let &(ref lock, ref cvar) = &*self.state.clone();
+        let mut state = lock.lock().unwrap();
+
+        state.idle = true;
+        cvar.notify_one();
+        info!(context, "Interrupting {}-IDLE... finished", self.name);
+    }
+
+    pub async fn fetch(&mut self, context: &Context, use_network: bool) {
+        {
+            let &(ref lock, _) = &*self.state.clone();
+            let mut state = lock.lock().unwrap();
+
+            if state.suspended {
+                return;
+            }
+
+            state.using_handle = true;
+        }
+
+        if use_network {
+            if let Err(err) = self.connect_and_fetch(context).await {
+                warn!(context, "connect+fetch failed: {}, reconnect & retry", err);
+                self.imap.trigger_reconnect();
+                if let Err(err) = self.connect_and_fetch(context).await {
+                    warn!(context, "connect+fetch failed: {}", err);
+                }
+            }
+        }
+        self.state.0.lock().unwrap().using_handle = false;
+    }
+
+    async fn connect_and_fetch(&mut self, context: &Context) -> Result<()> {
+        let prefix = format!("{}-fetch", self.name);
+        self.imap.connect_configured(context)?;
+        if let Some(watch_folder) = self.get_watch_folder(context) {
+            let start = std::time::Instant::now();
+            info!(context, "{} started...", prefix);
+            let res = self
+                .imap
+                .fetch(context, &watch_folder)
+                .await
+                .map_err(Into::into);
+            let elapsed = start.elapsed().as_millis();
+            info!(context, "{} done in {:.3} ms.", prefix, elapsed);
+
+            res
+        } else {
+            Err(format_err!("WatchFolder not found: not-set"))
+        }
+    }
+
+    fn get_watch_folder(&self, context: &Context) -> Option<String> {
+        match context.sql.get_raw_config(context, self.folder_config_name) {
+            Some(name) => Some(name),
+            None => {
+                if self.folder_config_name == "configured_inbox_folder" {
+                    // initialized with old version, so has not set configured_inbox_folder
+                    Some("INBOX".to_string())
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    pub fn idle(&self, context: &Context, use_network: bool) {
+        {
+            let &(ref lock, ref cvar) = &*self.state.clone();
+            let mut state = lock.lock().unwrap();
+
+            if state.jobs_needed {
+                info!(
+                    context,
+                    "{}-IDLE will not be started as it was interrupted while not idling.",
+                    self.name,
+                );
+                state.jobs_needed = false;
+                return;
+            }
+
+            if state.suspended {
+                while !state.idle {
+                    state = cvar.wait(state).unwrap();
+                }
+                state.idle = false;
+                return;
+            }
+
+            state.using_handle = true;
+
+            if !use_network {
+                state.using_handle = false;
+
+                while !state.idle {
+                    state = cvar.wait(state).unwrap();
+                }
+                state.idle = false;
+                return;
+            }
+        }
+
+        let prefix = format!("{}-IDLE", self.name);
+        let do_fake_idle = match self.imap.connect_configured(context) {
+            Ok(()) => {
+                if !self.imap.can_idle() {
+                    true // we have to do fake_idle
+                } else {
+                    let watch_folder = self.get_watch_folder(context);
+                    info!(context, "{} started...", prefix);
+                    let res = self.imap.idle(context, watch_folder);
+                    info!(context, "{} ended...", prefix);
+                    if let Err(err) = res {
+                        warn!(context, "{} failed: {} -> reconnecting", prefix, err);
+                        // something is borked, let's start afresh on the next occassion
+                        self.imap.disconnect(context);
+                    }
+                    false
+                }
+            }
+            Err(err) => {
+                info!(context, "{}-IDLE connection fail: {:?}", self.name, err);
+                // if the connection fails, use fake_idle to retry periodically
+                // fake_idle() will be woken up by interrupt_idle() as
+                // well so will act on maybe_network events
+                true
+            }
+        };
+        if do_fake_idle {
+            let watch_folder = self.get_watch_folder(context);
+            self.imap.fake_idle(context, watch_folder);
+        }
+
+        self.state.0.lock().unwrap().using_handle = false;
+    }
+}

src/key.rs

@@ -1,10 +1,9 @@
 //! Cryptographic key module
 
 use std::collections::BTreeMap;
-use std::fmt;
 use std::io::Cursor;
+use std::path::Path;
 
-use async_trait::async_trait;
 use num_traits::FromPrimitive;
 use pgp::composed::Deserializable;
 use pgp::ser::Serialize;
@@ -13,7 +12,7 @@ use pgp::types::{KeyTrait, SecretKeyTrait};
 use crate::config::Config;
 use crate::constants::*;
 use crate::context::Context;
-use crate::dc_tools::{time, EmailAddress, InvalidEmailError};
+use crate::dc_tools::{dc_write_file, time, EmailAddress, InvalidEmailError};
 use crate::sql;
 
 // Re-export key types
@@ -38,8 +37,6 @@ pub enum Error {
     NoConfiguredAddr,
     #[error("Configured address is invalid: {}", _0)]
     InvalidConfiguredAddr(#[from] InvalidEmailError),
-    #[error("no data provided")]
-    Empty,
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -49,9 +46,8 @@ pub type Result<T> = std::result::Result<T, Error>;
 /// This trait is implemented for rPGP's [SignedPublicKey] and
 /// [SignedSecretKey] types and makes working with them a little
 /// easier in the deltachat world.
-#[async_trait]
-pub trait DcKey: Serialize + Deserializable + KeyTrait + Clone {
-    type KeyType: Serialize + Deserializable + KeyTrait + Clone;
+pub trait DcKey: Serialize + Deserializable {
+    type KeyType: Serialize + Deserializable;
 
     /// Create a key from some bytes.
     fn from_slice(bytes: &[u8]) -> Result<Self::KeyType> {
@@ -68,178 +64,87 @@ pub trait DcKey: Serialize + Deserializable + KeyTrait + Clone {
         Self::from_slice(&bytes)
     }
 
-    /// Create a key from an ASCII-armored string.
-    ///
-    /// Returns the key and a map of any headers which might have been set in
-    /// the ASCII-armored representation.
-    fn from_asc(data: &str) -> Result<(Self::KeyType, BTreeMap<String, String>)> {
-        let bytes = data.as_bytes();
-        Self::KeyType::from_armor_single(Cursor::new(bytes)).map_err(Error::Pgp)
-    }
-
     /// Load the users' default key from the database.
-    async fn load_self(context: &Context) -> Result<Self::KeyType>;
+    fn load_self(context: &Context) -> Result<Self::KeyType>;
 
-    /// Serialise the key as bytes.
-    fn to_bytes(&self) -> Vec<u8> {
+    /// Serialise the key to a base64 string.
+    fn to_base64(&self) -> String {
         // Not using Serialize::to_bytes() to make clear *why* it is
         // safe to ignore this error.
         // Because we write to a Vec<u8> the io::Write impls never
         // fail and we can hide this error.
         let mut buf = Vec::new();
         self.to_writer(&mut buf).unwrap();
-        buf
-    }
-
-    /// Serialise the key to a base64 string.
-    fn to_base64(&self) -> String {
-        base64::encode(&DcKey::to_bytes(self))
-    }
-
-    /// Serialise the key to ASCII-armored representation.
-    ///
-    /// Each header line must be terminated by `\r\n`.  Only allows setting one
-    /// header as a simplification since that's the only way it's used so far.
-    // Since .to_armored_string() are actual methods on SignedPublicKey and
-    // SignedSecretKey we can not generically implement this.
-    fn to_asc(&self, header: Option<(&str, &str)>) -> String;
-
-    /// The fingerprint for the key.
-    fn fingerprint(&self) -> Fingerprint {
-        Fingerprint::new(KeyTrait::fingerprint(self))
+        base64::encode(&buf)
     }
 }
 
-#[async_trait]
 impl DcKey for SignedPublicKey {
     type KeyType = SignedPublicKey;
 
-    async fn load_self(context: &Context) -> Result<Self::KeyType> {
-        match context
-            .sql
-            .query_row(
-                r#"
+    fn load_self(context: &Context) -> Result<Self::KeyType> {
+        match context.sql.query_row(
+            r#"
             SELECT public_key
               FROM keypairs
              WHERE addr=(SELECT value FROM config WHERE keyname="configured_addr")
                AND is_default=1;
             "#,
-                paramsv![],
-                |row| row.get::<_, Vec<u8>>(0),
-            )
-            .await
-        {
+            params![],
+            |row| row.get::<_, Vec<u8>>(0),
+        ) {
             Ok(bytes) => Self::from_slice(&bytes),
             Err(sql::Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => {
-                let keypair = generate_keypair(context).await?;
+                let keypair = generate_keypair(context)?;
                 Ok(keypair.public)
             }
             Err(err) => Err(err.into()),
         }
     }
-
-    fn to_asc(&self, header: Option<(&str, &str)>) -> String {
-        // Not using .to_armored_string() to make clear *why* it is
-        // safe to ignore this error.
-        // Because we write to a Vec<u8> the io::Write impls never
-        // fail and we can hide this error.
-        let headers = header.map(|(key, value)| {
-            let mut m = BTreeMap::new();
-            m.insert(key.to_string(), value.to_string());
-            m
-        });
-        let mut buf = Vec::new();
-        self.to_armored_writer(&mut buf, headers.as_ref())
-            .unwrap_or_default();
-        std::string::String::from_utf8(buf).unwrap_or_default()
-    }
 }
 
-#[async_trait]
 impl DcKey for SignedSecretKey {
     type KeyType = SignedSecretKey;
 
-    async fn load_self(context: &Context) -> Result<Self::KeyType> {
-        match context
-            .sql
-            .query_row(
-                r#"
+    fn load_self(context: &Context) -> Result<Self::KeyType> {
+        match context.sql.query_row(
+            r#"
             SELECT private_key
               FROM keypairs
              WHERE addr=(SELECT value FROM config WHERE keyname="configured_addr")
                AND is_default=1;
             "#,
-                paramsv![],
-                |row| row.get::<_, Vec<u8>>(0),
-            )
-            .await
-        {
+            params![],
+            |row| row.get::<_, Vec<u8>>(0),
+        ) {
             Ok(bytes) => Self::from_slice(&bytes),
             Err(sql::Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => {
-                let keypair = generate_keypair(context).await?;
+                let keypair = generate_keypair(context)?;
                 Ok(keypair.secret)
             }
             Err(err) => Err(err.into()),
         }
     }
-
-    fn to_asc(&self, header: Option<(&str, &str)>) -> String {
-        // Not using .to_armored_string() to make clear *why* it is
-        // safe to do these unwraps.
-        // Because we write to a Vec<u8> the io::Write impls never
-        // fail and we can hide this error.  The string is always ASCII.
-        let headers = header.map(|(key, value)| {
-            let mut m = BTreeMap::new();
-            m.insert(key.to_string(), value.to_string());
-            m
-        });
-        let mut buf = Vec::new();
-        self.to_armored_writer(&mut buf, headers.as_ref())
-            .unwrap_or_default();
-        std::string::String::from_utf8(buf).unwrap_or_default()
-    }
 }
 
-/// Deltachat extension trait for secret keys.
-///
-/// Provides some convenience wrappers only applicable to [SignedSecretKey].
-pub trait DcSecretKey {
-    /// Create a public key from a private one.
-    fn split_public_key(&self) -> Result<SignedPublicKey>;
-}
-
-impl DcSecretKey for SignedSecretKey {
-    fn split_public_key(&self) -> Result<SignedPublicKey> {
-        self.verify()?;
-        let unsigned_pubkey = SecretKeyTrait::public_key(self);
-        let signed_pubkey = unsigned_pubkey.sign(self, || "".into())?;
-        Ok(signed_pubkey)
-    }
-}
-
-async fn generate_keypair(context: &Context) -> Result<KeyPair> {
+fn generate_keypair(context: &Context) -> Result<KeyPair> {
     let addr = context
         .get_config(Config::ConfiguredAddr)
-        .await
         .ok_or_else(|| Error::NoConfiguredAddr)?;
     let addr = EmailAddress::new(&addr)?;
-    let _guard = context.generating_key_mutex.lock().await;
+    let _guard = context.generating_key_mutex.lock().unwrap();
 
     // Check if the key appeared while we were waiting on the lock.
-    match context
-        .sql
-        .query_row(
-            r#"
+    match context.sql.query_row(
+        r#"
         SELECT public_key, private_key
           FROM keypairs
          WHERE addr=?1
            AND is_default=1;
         "#,
-            paramsv![addr],
-            |row| Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, Vec<u8>>(1)?)),
-        )
-        .await
-    {
+        params![addr],
+        |row| Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, Vec<u8>>(1)?)),
+    ) {
         Ok((pub_bytes, sec_bytes)) => Ok(KeyPair {
             addr,
             public: SignedPublicKey::from_slice(&pub_bytes)?,
@@ -247,13 +152,11 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
         }),
         Err(sql::Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => {
             let start = std::time::Instant::now();
-            let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType).await)
+            let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType))
                 .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?;
-            store_self_keypair(context, &keypair, KeyPairUse::Default).await?;
+            let keypair = crate::pgp::create_keypair(addr, keytype)?;
+            store_self_keypair(context, &keypair, KeyPairUse::Default)?;
             info!(
                 context,
                 "Keypair generated in {:.3}s.",
@@ -265,6 +168,198 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
     }
 }
 
+/// Cryptographic key
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum Key {
+    Public(SignedPublicKey),
+    Secret(SignedSecretKey),
+}
+
+impl From<SignedPublicKey> for Key {
+    fn from(key: SignedPublicKey) -> Self {
+        Key::Public(key)
+    }
+}
+
+impl From<SignedSecretKey> for Key {
+    fn from(key: SignedSecretKey) -> Self {
+        Key::Secret(key)
+    }
+}
+
+impl std::convert::TryFrom<Key> for SignedSecretKey {
+    type Error = ();
+
+    fn try_from(value: Key) -> std::result::Result<Self, Self::Error> {
+        match value {
+            Key::Public(_) => Err(()),
+            Key::Secret(key) => Ok(key),
+        }
+    }
+}
+
+impl<'a> std::convert::TryFrom<&'a Key> for &'a SignedSecretKey {
+    type Error = ();
+
+    fn try_from(value: &'a Key) -> std::result::Result<Self, Self::Error> {
+        match value {
+            Key::Public(_) => Err(()),
+            Key::Secret(key) => Ok(key),
+        }
+    }
+}
+
+impl std::convert::TryFrom<Key> for SignedPublicKey {
+    type Error = ();
+
+    fn try_from(value: Key) -> std::result::Result<Self, Self::Error> {
+        match value {
+            Key::Public(key) => Ok(key),
+            Key::Secret(_) => Err(()),
+        }
+    }
+}
+
+impl<'a> std::convert::TryFrom<&'a Key> for &'a SignedPublicKey {
+    type Error = ();
+
+    fn try_from(value: &'a Key) -> std::result::Result<Self, Self::Error> {
+        match value {
+            Key::Public(key) => Ok(key),
+            Key::Secret(_) => Err(()),
+        }
+    }
+}
+
+impl Key {
+    pub fn is_public(&self) -> bool {
+        match self {
+            Key::Public(_) => true,
+            Key::Secret(_) => false,
+        }
+    }
+
+    pub fn is_secret(&self) -> bool {
+        !self.is_public()
+    }
+
+    pub fn from_slice(bytes: &[u8], key_type: KeyType) -> Option<Self> {
+        if bytes.is_empty() {
+            return None;
+        }
+        let res: std::result::Result<Key, _> = match key_type {
+            KeyType::Public => SignedPublicKey::from_bytes(Cursor::new(bytes)).map(Into::into),
+            KeyType::Private => SignedSecretKey::from_bytes(Cursor::new(bytes)).map(Into::into),
+        };
+
+        match res {
+            Ok(key) => Some(key),
+            Err(err) => {
+                eprintln!("Invalid key bytes: {:?}", err);
+                None
+            }
+        }
+    }
+
+    pub fn from_armored_string(
+        data: &str,
+        key_type: KeyType,
+    ) -> Option<(Self, BTreeMap<String, String>)> {
+        let bytes = data.as_bytes();
+        let res: std::result::Result<(Key, _), _> = match key_type {
+            KeyType::Public => SignedPublicKey::from_armor_single(Cursor::new(bytes))
+                .map(|(k, h)| (Into::into(k), h)),
+            KeyType::Private => SignedSecretKey::from_armor_single(Cursor::new(bytes))
+                .map(|(k, h)| (Into::into(k), h)),
+        };
+
+        match res {
+            Ok(res) => Some(res),
+            Err(err) => {
+                eprintln!("Invalid key bytes: {:?}", err);
+                None
+            }
+        }
+    }
+
+    pub fn to_bytes(&self) -> Vec<u8> {
+        match self {
+            Key::Public(k) => k.to_bytes().unwrap_or_default(),
+            Key::Secret(k) => k.to_bytes().unwrap_or_default(),
+        }
+    }
+
+    pub fn verify(&self) -> bool {
+        match self {
+            Key::Public(k) => k.verify().is_ok(),
+            Key::Secret(k) => k.verify().is_ok(),
+        }
+    }
+
+    pub fn to_base64(&self) -> String {
+        let buf = self.to_bytes();
+        base64::encode(&buf)
+    }
+
+    pub fn to_armored_string(
+        &self,
+        headers: Option<&BTreeMap<String, String>>,
+    ) -> pgp::errors::Result<String> {
+        match self {
+            Key::Public(k) => k.to_armored_string(headers),
+            Key::Secret(k) => k.to_armored_string(headers),
+        }
+    }
+
+    /// Each header line must be terminated by `\r\n`
+    pub fn to_asc(&self, header: Option<(&str, &str)>) -> String {
+        let headers = header.map(|(key, value)| {
+            let mut m = BTreeMap::new();
+            m.insert(key.to_string(), value.to_string());
+            m
+        });
+
+        self.to_armored_string(headers.as_ref())
+            .expect("failed to serialize key")
+    }
+
+    pub fn write_asc_to_file(
+        &self,
+        file: impl AsRef<Path>,
+        context: &Context,
+    ) -> std::io::Result<()> {
+        let file_content = self.to_asc(None).into_bytes();
+
+        let res = dc_write_file(context, &file, &file_content);
+        if res.is_err() {
+            error!(context, "Cannot write key to {}", file.as_ref().display());
+        }
+        res
+    }
+
+    pub fn fingerprint(&self) -> String {
+        match self {
+            Key::Public(k) => hex::encode_upper(k.fingerprint()),
+            Key::Secret(k) => hex::encode_upper(k.fingerprint()),
+        }
+    }
+
+    pub fn formatted_fingerprint(&self) -> String {
+        let rawhex = self.fingerprint();
+        dc_format_fingerprint(&rawhex)
+    }
+
+    pub fn split_key(&self) -> Option<Key> {
+        match self {
+            Key::Public(_) => None,
+            Key::Secret(k) => {
+                let pub_key = k.public_key();
+                pub_key.sign(k, || "".into()).map(Key::Public).ok()
+            }
+        }
+    }
+}
+
 /// Use of a [KeyPair] for encryption or decryption.
 ///
 /// This is used by [store_self_keypair] to know what kind of key is
@@ -307,106 +402,53 @@ impl SaveKeyError {
 /// same key again overwrites it.
 ///
 /// [Config::ConfiguredAddr]: crate::config::Config::ConfiguredAddr
-pub async fn store_self_keypair(
+pub fn store_self_keypair(
     context: &Context,
     keypair: &KeyPair,
     default: KeyPairUse,
 ) -> std::result::Result<(), SaveKeyError> {
     // Everything should really be one transaction, more refactoring
     // is needed for that.
-    let public_key = DcKey::to_bytes(&keypair.public);
-    let secret_key = DcKey::to_bytes(&keypair.secret);
+    let public_key = keypair
+        .public
+        .to_bytes()
+        .map_err(|err| SaveKeyError::new("failed to serialise public key", err))?;
+    let secret_key = keypair
+        .secret
+        .to_bytes()
+        .map_err(|err| SaveKeyError::new("failed to serialise secret key", err))?;
     context
         .sql
         .execute(
             "DELETE FROM keypairs WHERE public_key=? OR private_key=?;",
-            paramsv![public_key, secret_key],
+            params![public_key, secret_key],
         )
-        .await
         .map_err(|err| SaveKeyError::new("failed to remove old use of key", err))?;
     if default == KeyPairUse::Default {
         context
             .sql
-            .execute("UPDATE keypairs SET is_default=0;", paramsv![])
-            .await
+            .execute("UPDATE keypairs SET is_default=0;", params![])
             .map_err(|err| SaveKeyError::new("failed to clear default", err))?;
     }
     let is_default = match default {
-        KeyPairUse::Default => true as i32,
-        KeyPairUse::ReadOnly => false as i32,
+        KeyPairUse::Default => true,
+        KeyPairUse::ReadOnly => false,
     };
-
-    let addr = keypair.addr.to_string();
-    let t = time();
-
-    let params = paramsv![addr, is_default, public_key, secret_key, t];
     context
         .sql
         .execute(
             "INSERT INTO keypairs (addr, is_default, public_key, private_key, created)
                 VALUES (?,?,?,?,?);",
-            params,
+            params![
+                keypair.addr.to_string(),
+                is_default as i32,
+                public_key,
+                secret_key,
+                time()
+            ],
         )
-        .await
-        .map_err(|err| SaveKeyError::new("failed to insert keypair", err))?;
-
-    Ok(())
-}
-
-/// A key fingerprint
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Fingerprint(Vec<u8>);
-
-impl Fingerprint {
-    pub fn new(v: Vec<u8>) -> Fingerprint {
-        Fingerprint(v)
-    }
-
-    /// Make a hex string from the fingerprint.
-    ///
-    /// Use [std::fmt::Display] or [ToString::to_string] to get a
-    /// human-readable formatted string.
-    pub fn hex(&self) -> String {
-        hex::encode_upper(&self.0)
-    }
-}
-
-/// Make a human-readable fingerprint.
-impl fmt::Display for Fingerprint {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Split key into chunks of 4 with space and newline at 20 chars
-        for (i, c) in self.hex().chars().enumerate() {
-            if i > 0 && i % 20 == 0 {
-                writeln!(f)?;
-            } else if i > 0 && i % 4 == 0 {
-                write!(f, " ")?;
-            }
-            write!(f, "{}", c)?;
-        }
-        Ok(())
-    }
-}
-
-/// Parse a human-readable or otherwise formatted fingerprint.
-impl std::str::FromStr for Fingerprint {
-    type Err = hex::FromHexError;
-
-    fn from_str(input: &str) -> std::result::Result<Self, Self::Err> {
-        let hex_repr: String = input
-            .chars()
-            .filter(|&c| c >= '0' && c <= '9' || c >= 'A' && c <= 'F')
-            .collect();
-        let v: Vec<u8> = hex::decode(hex_repr)?;
-        Ok(Fingerprint(v))
-    }
-}
-
-/// Bring a human-readable or otherwise formatted fingerprint back to the 40-characters-uppercase-hex format.
-pub fn dc_normalize_fingerprint(fp: &str) -> String {
-    fp.to_uppercase()
-        .chars()
-        .filter(|&c| c >= '0' && c <= '9' || c >= 'A' && c <= 'F')
-        .collect()
+        .map(|_| ())
+        .map_err(|err| SaveKeyError::new("failed to insert keypair", err))
 }
 
 /// Make a fingerprint human-readable, in hex format.
@@ -427,12 +469,20 @@ pub fn dc_format_fingerprint(fingerprint: &str) -> String {
     res
 }
 
+/// Bring a human-readable or otherwise formatted fingerprint back to the 40-characters-uppercase-hex format.
+pub fn dc_normalize_fingerprint(fp: &str) -> String {
+    fp.to_uppercase()
+        .chars()
+        .filter(|&c| c >= '0' && c <= '9' || c >= 'A' && c <= 'F')
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::test_utils::*;
+    use std::convert::TryFrom;
 
-    use async_std::sync::Arc;
     use lazy_static::lazy_static;
 
     lazy_static! {
@@ -446,19 +496,9 @@ mod tests {
         assert_eq!(fingerprint, "1234567890ABCDABCDEFABCDEF");
     }
 
-    #[test]
-    fn test_format_fingerprint() {
-        let fingerprint = dc_format_fingerprint("1234567890ABCDABCDEFABCDEF1234567890ABCD");
-
-        assert_eq!(
-            fingerprint,
-            "1234 5678 90AB CDAB CDEF\nABCD EF12 3456 7890 ABCD"
-        );
-    }
-
     #[test]
     fn test_from_armored_string() {
-        let (private_key, _) = SignedSecretKey::from_asc(
+        let (private_key, _) = Key::from_armored_string(
             "-----BEGIN PGP PRIVATE KEY BLOCK-----
 
 xcLYBF0fgz4BCADnRUV52V4xhSsU56ZaAn3+3oG86MZhXy4X8w14WZZDf0VJGeTh
@@ -516,150 +556,152 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
 7yPJeQ==
 =KZk/
 -----END PGP PRIVATE KEY BLOCK-----",
+            KeyType::Private,
         )
-        .expect("failed to decode");
-        let binary = DcKey::to_bytes(&private_key);
-        SignedSecretKey::from_slice(&binary).expect("invalid private key");
+        .expect("failed to decode"); // NOTE: if you take out the ===GU1/ part, everything passes!
+        let binary = private_key.to_bytes();
+        Key::from_slice(&binary, KeyType::Private).expect("invalid private key");
     }
 
     #[test]
-    fn test_asc_roundtrip() {
-        let key = KEYPAIR.public.clone();
-        let asc = key.to_asc(Some(("spam", "ham")));
-        let (key2, hdrs) = SignedPublicKey::from_asc(&asc).unwrap();
-        assert_eq!(key, key2);
-        assert_eq!(hdrs.len(), 1);
-        assert_eq!(hdrs.get("spam"), Some(&String::from("ham")));
+    fn test_format_fingerprint() {
+        let fingerprint = dc_format_fingerprint("1234567890ABCDABCDEFABCDEF1234567890ABCD");
 
-        let key = KEYPAIR.secret.clone();
-        let asc = key.to_asc(Some(("spam", "ham")));
-        let (key2, hdrs) = SignedSecretKey::from_asc(&asc).unwrap();
-        assert_eq!(key, key2);
-        assert_eq!(hdrs.len(), 1);
-        assert_eq!(hdrs.get("spam"), Some(&String::from("ham")));
+        assert_eq!(
+            fingerprint,
+            "1234 5678 90AB CDAB CDEF\nABCD EF12 3456 7890 ABCD"
+        );
     }
 
     #[test]
     fn test_from_slice_roundtrip() {
-        let public_key = KEYPAIR.public.clone();
-        let private_key = KEYPAIR.secret.clone();
+        let public_key = Key::from(KEYPAIR.public.clone());
+        let private_key = Key::from(KEYPAIR.secret.clone());
 
-        let binary = DcKey::to_bytes(&public_key);
-        let public_key2 = SignedPublicKey::from_slice(&binary).expect("invalid public key");
+        let binary = public_key.to_bytes();
+        let public_key2 = Key::from_slice(&binary, KeyType::Public).expect("invalid public key");
         assert_eq!(public_key, public_key2);
 
-        let binary = DcKey::to_bytes(&private_key);
-        let private_key2 = SignedSecretKey::from_slice(&binary).expect("invalid private key");
+        let binary = private_key.to_bytes();
+        let private_key2 = Key::from_slice(&binary, KeyType::Private).expect("invalid private key");
         assert_eq!(private_key, private_key2);
     }
 
     #[test]
     fn test_from_slice_bad_data() {
         let mut bad_data: [u8; 4096] = [0; 4096];
+
         for i in 0..4096 {
             bad_data[i] = (i & 0xff) as u8;
         }
+
         for j in 0..(4096 / 40) {
-            let slice = &bad_data[j..j + 4096 / 2 + j];
-            assert!(SignedPublicKey::from_slice(slice).is_err());
-            assert!(SignedSecretKey::from_slice(slice).is_err());
+            let bad_key = Key::from_slice(
+                &bad_data[j..j + 4096 / 2 + j],
+                if 0 != j & 1 {
+                    KeyType::Public
+                } else {
+                    KeyType::Private
+                },
+            );
+            assert!(bad_key.is_none());
         }
     }
 
     #[test]
-    fn test_base64_roundtrip() {
-        let key = KEYPAIR.public.clone();
-        let base64 = key.to_base64();
-        let key2 = SignedPublicKey::from_base64(&base64).unwrap();
-        assert_eq!(key, key2);
-    }
-
-    #[async_std::test]
-    async fn test_load_self_existing() {
+    fn test_load_self_existing() {
         let alice = alice_keypair();
-        let t = dummy_context().await;
-        configure_alice_keypair(&t.ctx).await;
-        let pubkey = SignedPublicKey::load_self(&t.ctx).await.unwrap();
+        let t = dummy_context();
+        configure_alice_keypair(&t.ctx);
+        let pubkey = SignedPublicKey::load_self(&t.ctx).unwrap();
         assert_eq!(alice.public, pubkey);
-        let seckey = SignedSecretKey::load_self(&t.ctx).await.unwrap();
+        let seckey = SignedSecretKey::load_self(&t.ctx).unwrap();
         assert_eq!(alice.secret, seckey);
     }
 
-    #[async_std::test]
+    #[test]
     #[ignore] // generating keys is expensive
-    async fn test_load_self_generate_public() {
-        let t = dummy_context().await;
+    fn test_load_self_generate_public() {
+        let t = dummy_context();
         t.ctx
             .set_config(Config::ConfiguredAddr, Some("alice@example.com"))
-            .await
             .unwrap();
-        let key = SignedPublicKey::load_self(&t.ctx).await;
+        let key = SignedPublicKey::load_self(&t.ctx);
         assert!(key.is_ok());
     }
 
-    #[async_std::test]
+    #[test]
     #[ignore] // generating keys is expensive
-    async fn test_load_self_generate_secret() {
-        let t = dummy_context().await;
+    fn test_load_self_generate_secret() {
+        let t = dummy_context();
         t.ctx
             .set_config(Config::ConfiguredAddr, Some("alice@example.com"))
-            .await
             .unwrap();
-        let key = SignedSecretKey::load_self(&t.ctx).await;
+        let key = SignedSecretKey::load_self(&t.ctx);
         assert!(key.is_ok());
     }
 
-    #[async_std::test]
+    #[test]
     #[ignore] // generating keys is expensive
-    async fn test_load_self_generate_concurrent() {
+    fn test_load_self_generate_concurrent() {
+        use std::sync::Arc;
         use std::thread;
 
-        let t = dummy_context().await;
+        let t = dummy_context();
         t.ctx
             .set_config(Config::ConfiguredAddr, Some("alice@example.com"))
-            .await
             .unwrap();
-        let ctx = t.ctx.clone();
-        let ctx0 = ctx.clone();
-        let thr0 =
-            thread::spawn(move || async_std::task::block_on(SignedPublicKey::load_self(&ctx0)));
-        let ctx1 = ctx.clone();
-        let thr1 =
-            thread::spawn(move || async_std::task::block_on(SignedPublicKey::load_self(&ctx1)));
+        let ctx = Arc::new(t.ctx);
+        let ctx0 = Arc::clone(&ctx);
+        let thr0 = thread::spawn(move || SignedPublicKey::load_self(&ctx0));
+        let ctx1 = Arc::clone(&ctx);
+        let thr1 = thread::spawn(move || SignedPublicKey::load_self(&ctx1));
         let res0 = thr0.join().unwrap();
         let res1 = thr1.join().unwrap();
         assert_eq!(res0.unwrap(), res1.unwrap());
     }
 
     #[test]
-    fn test_split_key() {
-        let pubkey = KEYPAIR.secret.split_public_key().unwrap();
-        assert_eq!(pubkey.primary_key, KEYPAIR.public.primary_key);
+    fn test_ascii_roundtrip() {
+        let public_key = Key::from(KEYPAIR.public.clone());
+        let private_key = Key::from(KEYPAIR.secret.clone());
+
+        let s = public_key.to_armored_string(None).unwrap();
+        let (public_key2, _) =
+            Key::from_armored_string(&s, KeyType::Public).expect("invalid public key");
+        assert_eq!(public_key, public_key2);
+
+        let s = private_key.to_armored_string(None).unwrap();
+        println!("{}", &s);
+        let (private_key2, _) =
+            Key::from_armored_string(&s, KeyType::Private).expect("invalid private key");
+        assert_eq!(private_key, private_key2);
     }
 
-    #[async_std::test]
-    async fn test_save_self_key_twice() {
+    #[test]
+    fn test_split_key() {
+        let private_key = Key::from(KEYPAIR.secret.clone());
+        let public_wrapped = private_key.split_key().unwrap();
+        let public = SignedPublicKey::try_from(public_wrapped).unwrap();
+        assert_eq!(public.primary_key, KEYPAIR.public.primary_key);
+    }
+
+    #[test]
+    fn test_save_self_key_twice() {
         // Saving the same key twice should result in only one row in
         // the keypairs table.
-        let t = dummy_context().await;
-        let ctx = Arc::new(t.ctx);
-
-        let ctx1 = ctx.clone();
-        let nrows = || async {
-            ctx1.sql
-                .query_get_value::<u32>(&ctx1, "SELECT COUNT(*) FROM keypairs;", paramsv![])
-                .await
+        let t = dummy_context();
+        let nrows = || {
+            t.ctx
+                .sql
+                .query_get_value::<_, u32>(&t.ctx, "SELECT COUNT(*) FROM keypairs;", params![])
                 .unwrap()
         };
-        assert_eq!(nrows().await, 0);
-        store_self_keypair(&ctx, &KEYPAIR, KeyPairUse::Default)
-            .await
-            .unwrap();
-        assert_eq!(nrows().await, 1);
-        store_self_keypair(&ctx, &KEYPAIR, KeyPairUse::Default)
-            .await
-            .unwrap();
-        assert_eq!(nrows().await, 1);
+        assert_eq!(nrows(), 0);
+        store_self_keypair(&t.ctx, &KEYPAIR, KeyPairUse::Default).unwrap();
+        assert_eq!(nrows(), 1);
+        store_self_keypair(&t.ctx, &KEYPAIR, KeyPairUse::Default).unwrap();
+        assert_eq!(nrows(), 1);
     }
 
     // Convenient way to create a new key if you need one, run with
@@ -682,35 +724,4 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
     //     )
     //     .unwrap();
     // }
-
-    #[test]
-    fn test_fingerprint_from_str() {
-        let res = Fingerprint::new(vec![1, 2, 4, 8, 16, 32, 64, 128, 255]);
-
-        let fp: Fingerprint = "0102040810204080FF".parse().unwrap();
-        assert_eq!(fp, res);
-
-        let fp: Fingerprint = "zzzz 0102 0408\n1020 4080 FF zzz".parse().unwrap();
-        assert_eq!(fp, res);
-
-        let err = "1".parse::<Fingerprint>().err().unwrap();
-        assert_eq!(err, hex::FromHexError::OddLength);
-    }
-
-    #[test]
-    fn test_fingerprint_hex() {
-        let fp = Fingerprint::new(vec![1, 2, 4, 8, 16, 32, 64, 128, 255]);
-        assert_eq!(fp.hex(), "0102040810204080FF");
-    }
-
-    #[test]
-    fn test_fingerprint_to_string() {
-        let fp = Fingerprint::new(vec![
-            1, 2, 4, 8, 16, 32, 64, 128, 255, 1, 2, 4, 8, 16, 32, 64, 128, 255,
-        ]);
-        assert_eq!(
-            fp.to_string(),
-            "0102 0408 1020 4080 FF01\n0204 0810 2040 80FF"
-        );
-    }
 }

src/keyring.rs

@@ -1,92 +1,45 @@
-//! Keyring to perform rpgp operations with.
-
-use anyhow::Result;
+use std::borrow::Cow;
 
+use crate::constants::KeyType;
 use crate::context::Context;
-use crate::key::{self, DcKey};
+use crate::key::Key;
+use crate::sql::Sql;
 
-/// An in-memory keyring.
-///
-/// Instances are usually constructed just for the rpgp operation and
-/// short-lived.
-#[derive(Clone, Debug, Default)]
-pub struct Keyring<T>
-where
-    T: DcKey,
-{
-    keys: Vec<T>,
+#[derive(Default, Clone, Debug)]
+pub struct Keyring<'a> {
+    keys: Vec<Cow<'a, Key>>,
 }
 
-impl<T> Keyring<T>
-where
-    T: DcKey<KeyType = T>,
-{
-    /// New empty keyring.
-    pub fn new() -> Keyring<T> {
-        Keyring { keys: Vec::new() }
+impl<'a> Keyring<'a> {
+    pub fn add_owned(&mut self, key: Key) {
+        self.add(Cow::Owned(key))
     }
 
-    /// Create a new keyring with the the user's secret key loaded.
-    pub async fn new_self(context: &Context) -> Result<Keyring<T>, key::Error> {
-        let mut keyring: Keyring<T> = Keyring::new();
-        keyring.load_self(context).await?;
-        Ok(keyring)
+    pub fn add_ref(&mut self, key: &'a Key) {
+        self.add(Cow::Borrowed(key))
     }
 
-    /// Load the user's key into the keyring.
-    pub async fn load_self(&mut self, context: &Context) -> Result<(), key::Error> {
-        self.add(T::load_self(context).await?);
-        Ok(())
-    }
-
-    /// Add a key to the keyring.
-    pub fn add(&mut self, key: T) {
+    fn add(&mut self, key: Cow<'a, Key>) {
         self.keys.push(key);
     }
 
-    pub fn len(&self) -> usize {
-        self.keys.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.keys.is_empty()
-    }
-
-    /// A vector with reference to all the keys in the keyring.
-    pub fn keys(&self) -> &[T] {
+    pub fn keys(&self) -> &[Cow<'a, Key>] {
         &self.keys
     }
-}
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::key::{SignedPublicKey, SignedSecretKey};
-    use crate::test_utils::*;
-
-    #[test]
-    fn test_keyring_add_keys() {
-        let alice = alice_keypair();
-        let mut pub_ring: Keyring<SignedPublicKey> = Keyring::new();
-        pub_ring.add(alice.public.clone());
-        assert_eq!(pub_ring.keys(), [alice.public]);
-
-        let mut sec_ring: Keyring<SignedSecretKey> = Keyring::new();
-        sec_ring.add(alice.secret.clone());
-        assert_eq!(sec_ring.keys(), [alice.secret]);
-    }
-
-    #[async_std::test]
-    async fn test_keyring_load_self() {
-        // new_self() implies load_self()
-        let t = dummy_context().await;
-        configure_alice_keypair(&t.ctx).await;
-        let alice = alice_keypair();
-
-        let pub_ring: Keyring<SignedPublicKey> = Keyring::new_self(&t.ctx).await.unwrap();
-        assert_eq!(pub_ring.keys(), [alice.public]);
-
-        let sec_ring: Keyring<SignedSecretKey> = Keyring::new_self(&t.ctx).await.unwrap();
-        assert_eq!(sec_ring.keys(), [alice.secret]);
+    pub fn load_self_private_for_decrypting(
+        &mut self,
+        context: &Context,
+        self_addr: impl AsRef<str>,
+        sql: &Sql,
+    ) -> bool {
+        sql.query_get_value(
+            context,
+            "SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;",
+            &[self_addr.as_ref()],
+        )
+        .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Private))
+        .map(|key| self.add_owned(key))
+        .is_some()
     }
 }

src/lib.rs

@@ -14,22 +14,11 @@ extern crate strum_macros;
 #[macro_use]
 extern crate debug_stub_derive;
 
-pub trait ToSql: rusqlite::ToSql + Send + Sync {}
-
-impl<T: rusqlite::ToSql + Send + Sync> ToSql for T {}
-
 #[macro_use]
 pub mod log;
 #[macro_use]
 pub mod error;
 
-#[cfg(feature = "internals")]
-#[macro_use]
-pub mod sql;
-#[cfg(not(feature = "internals"))]
-#[macro_use]
-mod sql;
-
 pub mod headerdef;
 
 pub(crate) mod events;
@@ -47,9 +36,9 @@ pub mod context;
 mod e2ee;
 mod imap;
 pub mod imex;
-mod scheduler;
 #[macro_use]
 pub mod job;
+mod job_thread;
 pub mod key;
 mod keyring;
 pub mod location;
@@ -67,6 +56,7 @@ pub mod qr;
 pub mod securejoin;
 mod simplify;
 mod smtp;
+pub mod sql;
 pub mod stock;
 mod token;
 #[macro_use]

src/location.rs

@@ -10,10 +10,11 @@ use crate::context::*;
 use crate::dc_tools::*;
 use crate::error::{ensure, Error};
 use crate::events::Event;
-use crate::job::{self, Job};
+use crate::job::{self, job_action_exists, job_add, Job};
 use crate::message::{Message, MsgId};
 use crate::mimeparser::SystemMessage;
 use crate::param::*;
+use crate::sql;
 use crate::stock::StockMessage;
 
 /// Location record
@@ -190,103 +191,91 @@ impl Kml {
 }
 
 // location streaming
-pub async fn send_locations_to_chat(context: &Context, chat_id: ChatId, seconds: i64) {
+pub fn send_locations_to_chat(context: &Context, chat_id: ChatId, seconds: i64) {
     let now = time();
     if !(seconds < 0 || chat_id.is_special()) {
-        let is_sending_locations_before = is_sending_locations_to_chat(context, chat_id).await;
-        if context
-            .sql
-            .execute(
-                "UPDATE chats    \
+        let is_sending_locations_before = is_sending_locations_to_chat(context, chat_id);
+        if sql::execute(
+            context,
+            &context.sql,
+            "UPDATE chats    \
              SET locations_send_begin=?,        \
              locations_send_until=?  \
              WHERE id=?",
-                paramsv![
-                    if 0 != seconds { now } else { 0 },
-                    if 0 != seconds { now + seconds } else { 0 },
-                    chat_id,
-                ],
-            )
-            .await
-            .is_ok()
+            params![
+                if 0 != seconds { now } else { 0 },
+                if 0 != seconds { now + seconds } else { 0 },
+                chat_id,
+            ],
+        )
+        .is_ok()
         {
             if 0 != seconds && !is_sending_locations_before {
                 let mut msg = Message::new(Viewtype::Text);
-                msg.text = Some(
-                    context
-                        .stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0)
-                        .await,
-                );
+                msg.text =
+                    Some(context.stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0));
                 msg.param.set_cmd(SystemMessage::LocationStreamingEnabled);
-                chat::send_msg(context, chat_id, &mut msg)
-                    .await
-                    .unwrap_or_default();
+                chat::send_msg(context, chat_id, &mut msg).unwrap_or_default();
             } else if 0 == seconds && is_sending_locations_before {
-                let stock_str = context
-                    .stock_system_msg(StockMessage::MsgLocationDisabled, "", "", 0)
-                    .await;
-                chat::add_info_msg(context, chat_id, stock_str).await;
+                let stock_str =
+                    context.stock_system_msg(StockMessage::MsgLocationDisabled, "", "", 0);
+                chat::add_info_msg(context, chat_id, stock_str);
             }
-            context.emit_event(Event::ChatModified(chat_id));
+            context.call_cb(Event::ChatModified(chat_id));
             if 0 != seconds {
-                schedule_maybe_send_locations(context, false).await;
-                job::add(
+                schedule_MAYBE_SEND_LOCATIONS(context, false);
+                job_add(
                     context,
-                    job::Job::new(
-                        job::Action::MaybeSendLocationsEnded,
-                        chat_id.to_u32(),
-                        Params::new(),
-                        seconds + 1,
-                    ),
-                )
-                .await;
+                    job::Action::MaybeSendLocationsEnded,
+                    chat_id.to_u32() as i32,
+                    Params::new(),
+                    seconds + 1,
+                );
             }
         }
     }
 }
 
-async fn schedule_maybe_send_locations(context: &Context, force_schedule: bool) {
-    if force_schedule || !job::action_exists(context, job::Action::MaybeSendLocations).await {
-        job::add(
+#[allow(non_snake_case)]
+fn schedule_MAYBE_SEND_LOCATIONS(context: &Context, force_schedule: bool) {
+    if force_schedule || !job_action_exists(context, job::Action::MaybeSendLocations) {
+        job_add(
             context,
-            job::Job::new(job::Action::MaybeSendLocations, 0, Params::new(), 60),
-        )
-        .await;
+            job::Action::MaybeSendLocations,
+            0,
+            Params::new(),
+            60,
+        );
     };
 }
 
-pub async fn is_sending_locations_to_chat(context: &Context, chat_id: ChatId) -> bool {
+pub fn is_sending_locations_to_chat(context: &Context, chat_id: ChatId) -> bool {
     context
         .sql
         .exists(
             "SELECT id  FROM chats  WHERE (? OR id=?)   AND locations_send_until>?;",
-            paramsv![if chat_id.is_unset() { 1 } else { 0 }, chat_id, time()],
+            params![if chat_id.is_unset() { 1 } else { 0 }, chat_id, time()],
         )
-        .await
         .unwrap_or_default()
 }
 
-pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64) -> bool {
+pub fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64) -> bool {
     if latitude == 0.0 && longitude == 0.0 {
         return true;
     }
     let mut continue_streaming = false;
 
-    if let Ok(chats) = context
-        .sql
-        .query_map(
-            "SELECT id FROM chats WHERE locations_send_until>?;",
-            paramsv![time()],
-            |row| row.get::<_, i32>(0),
-            |chats| chats.collect::<Result<Vec<_>, _>>().map_err(Into::into),
-        )
-        .await
-    {
+    if let Ok(chats) = context.sql.query_map(
+        "SELECT id FROM chats WHERE locations_send_until>?;",
+        params![time()],
+        |row| row.get::<_, i32>(0),
+        |chats| chats.collect::<Result<Vec<_>, _>>().map_err(Into::into),
+    ) {
         for chat_id in chats {
             if let Err(err) = context.sql.execute(
                     "INSERT INTO locations  \
                      (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);",
-                    paramsv![
+                    params![
                         latitude,
                         longitude,
                         accuracy,
@@ -294,22 +283,22 @@ pub async fn set(context: &Context, latitude: f64, longitude: f64, accuracy: f64
                         chat_id,
                         DC_CONTACT_ID_SELF,
                     ]
-            ).await {
+            ) {
                 warn!(context, "failed to store location {:?}", err);
             } else {
                 continue_streaming = true;
             }
         }
         if continue_streaming {
-            context.emit_event(Event::LocationChanged(Some(DC_CONTACT_ID_SELF)));
+            context.call_cb(Event::LocationChanged(Some(DC_CONTACT_ID_SELF)));
         };
-        schedule_maybe_send_locations(context, false).await;
+        schedule_MAYBE_SEND_LOCATIONS(context, false);
     }
 
     continue_streaming
 }
 
-pub async fn get_range(
+pub fn get_range(
     context: &Context,
     chat_id: ChatId,
     contact_id: u32,
@@ -328,7 +317,7 @@ pub async fn get_range(
              AND (? OR l.from_id=?) \
              AND (l.independent=1 OR (l.timestamp>=? AND l.timestamp<=?)) \
              ORDER BY l.timestamp DESC, l.id DESC, msg_id DESC;",
-            paramsv![
+            params![
                 if chat_id.is_unset() { 1 } else { 0 },
                 chat_id,
                 if contact_id == 0 { 1 } else { 0 },
@@ -367,7 +356,6 @@ pub async fn get_range(
                 Ok(ret)
             },
         )
-        .await
         .unwrap_or_default()
 }
 
@@ -376,33 +364,28 @@ fn is_marker(txt: &str) -> bool {
 }
 
 /// Deletes all locations from the database.
-pub async fn delete_all(context: &Context) -> Result<(), Error> {
-    context
-        .sql
-        .execute("DELETE FROM locations;", paramsv![])
-        .await?;
-    context.emit_event(Event::LocationChanged(None));
+pub fn delete_all(context: &Context) -> Result<(), Error> {
+    sql::execute(context, &context.sql, "DELETE FROM locations;", params![])?;
+    context.call_cb(Event::LocationChanged(None));
     Ok(())
 }
 
-pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32), Error> {
+pub fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32), Error> {
     let mut last_added_location_id = 0;
 
     let self_addr = context
         .get_config(Config::ConfiguredAddr)
-        .await
         .unwrap_or_default();
 
     let (locations_send_begin, locations_send_until, locations_last_sent) = context.sql.query_row(
         "SELECT locations_send_begin, locations_send_until, locations_last_sent  FROM chats  WHERE id=?;",
-        paramsv![chat_id], |row| {
+        params![chat_id], |row| {
             let send_begin: i64 = row.get(0)?;
             let send_until: i64 = row.get(1)?;
             let last_sent: i64 = row.get(2)?;
 
             Ok((send_begin, send_until, last_sent))
-        })
-        .await?;
+        })?;
 
     let now = time();
     let mut location_count = 0;
@@ -421,7 +404,7 @@ pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)
              AND independent=0 \
              GROUP BY timestamp \
              ORDER BY timestamp;",
-            paramsv![DC_CONTACT_ID_SELF, locations_send_begin, locations_last_sent, DC_CONTACT_ID_SELF],
+            params![DC_CONTACT_ID_SELF, locations_send_begin, locations_last_sent, DC_CONTACT_ID_SELF],
             |row| {
                 let location_id: i32 = row.get(0)?;
                 let latitude: f64 = row.get(1)?;
@@ -446,7 +429,7 @@ pub async fn get_kml(context: &Context, chat_id: ChatId) -> Result<(String, u32)
                 }
                 Ok(())
             }
-        ).await?;
+        )?;
         ret += "</Document>\n</kml>";
     }
 
@@ -479,38 +462,37 @@ pub fn get_message_kml(timestamp: i64, latitude: f64, longitude: f64) -> String
     )
 }
 
-pub async fn set_kml_sent_timestamp(
+pub fn set_kml_sent_timestamp(
     context: &Context,
     chat_id: ChatId,
     timestamp: i64,
 ) -> Result<(), Error> {
-    context
-        .sql
-        .execute(
-            "UPDATE chats SET locations_last_sent=? WHERE id=?;",
-            paramsv![timestamp, chat_id],
-        )
-        .await?;
+    sql::execute(
+        context,
+        &context.sql,
+        "UPDATE chats SET locations_last_sent=? WHERE id=?;",
+        params![timestamp, chat_id],
+    )?;
+
     Ok(())
 }
 
-pub async fn set_msg_location_id(
+pub fn set_msg_location_id(
     context: &Context,
     msg_id: MsgId,
     location_id: u32,
 ) -> Result<(), Error> {
-    context
-        .sql
-        .execute(
-            "UPDATE msgs SET location_id=? WHERE id=?;",
-            paramsv![location_id, msg_id],
-        )
-        .await?;
+    sql::execute(
+        context,
+        &context.sql,
+        "UPDATE msgs SET location_id=? WHERE id=?;",
+        params![location_id, msg_id],
+    )?;
 
     Ok(())
 }
 
-pub async fn save(
+pub fn save(
     context: &Context,
     chat_id: ChatId,
     contact_id: u32,
@@ -518,66 +500,54 @@ pub async fn save(
     independent: bool,
 ) -> Result<u32, Error> {
     ensure!(!chat_id.is_special(), "Invalid chat id");
-
-    let mut newest_timestamp = 0;
-    let mut newest_location_id = 0;
-
-    for location in locations {
-        let &Location {
-            timestamp,
-            latitude,
-            longitude,
-            accuracy,
-            ..
-        } = location;
-        context
-            .sql
-            .with_conn(move |mut conn| {
-                let mut stmt_test = conn
-                    .prepare_cached("SELECT id FROM locations WHERE timestamp=? AND from_id=?")?;
-                let mut stmt_insert = conn.prepare_cached(
-                    "INSERT INTO locations\
+    context
+        .sql
+        .prepare2(
+            "SELECT id FROM locations WHERE timestamp=? AND from_id=?",
+            "INSERT INTO locations\
              (timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
              VALUES (?,?,?,?,?,?,?);",
-                )?;
+            |mut stmt_test, mut stmt_insert, conn| {
+                let mut newest_timestamp = 0;
+                let mut newest_location_id = 0;
 
-                let exists = stmt_test.exists(paramsv![timestamp, contact_id as i32])?;
+                for location in locations {
+                    let exists =
+                        stmt_test.exists(params![location.timestamp, contact_id as i32])?;
 
-                if independent || !exists {
-                    stmt_insert.execute(paramsv![
-                        timestamp,
-                        contact_id as i32,
-                        chat_id,
-                        latitude,
-                        longitude,
-                        accuracy,
-                        independent,
-                    ])?;
-
-                    if timestamp > newest_timestamp {
-                        // okay to drop, as we use cached prepared statements
-                        drop(stmt_test);
-                        drop(stmt_insert);
-                        newest_timestamp = timestamp;
-                        newest_location_id = crate::sql::get_rowid2(
-                            &mut conn,
-                            "locations",
-                            "timestamp",
-                            timestamp,
-                            "from_id",
+                    if independent || !exists {
+                        stmt_insert.execute(params![
+                            location.timestamp,
                             contact_id as i32,
-                        )?;
+                            chat_id,
+                            location.latitude,
+                            location.longitude,
+                            location.accuracy,
+                            independent,
+                        ])?;
+
+                        if location.timestamp > newest_timestamp {
+                            newest_timestamp = location.timestamp;
+                            newest_location_id = sql::get_rowid2_with_conn(
+                                context,
+                                conn,
+                                "locations",
+                                "timestamp",
+                                location.timestamp,
+                                "from_id",
+                                contact_id as i32,
+                            );
+                        }
                     }
                 }
-                Ok(())
-            })
-            .await?;
-    }
-
-    Ok(newest_location_id)
+                Ok(newest_location_id)
+            },
+        )
+        .map_err(Into::into)
 }
 
-pub(crate) async fn job_maybe_send_locations(context: &Context, _job: &Job) -> job::Status {
+#[allow(non_snake_case)]
+pub(crate) fn JobMaybeSendLocations(context: &Context, _job: &Job) -> job::Status {
     let now = time();
     let mut continue_streaming = false;
     info!(
@@ -585,118 +555,101 @@ pub(crate) async fn job_maybe_send_locations(context: &Context, _job: &Job) -> j
         " ----------------- MAYBE_SEND_LOCATIONS -------------- ",
     );
 
-    let rows = context
-        .sql
-        .query_map(
-            "SELECT id, locations_send_begin, locations_last_sent \
+    if let Ok(rows) = context.sql.query_map(
+        "SELECT id, locations_send_begin, locations_last_sent \
          FROM chats \
          WHERE locations_send_until>?;",
-            paramsv![now],
-            |row| {
-                let chat_id: ChatId = row.get(0)?;
-                let locations_send_begin: i64 = row.get(1)?;
-                let locations_last_sent: i64 = row.get(2)?;
-                continue_streaming = true;
+        params![now],
+        |row| {
+            let chat_id: ChatId = row.get(0)?;
+            let locations_send_begin: i64 = row.get(1)?;
+            let locations_last_sent: i64 = row.get(2)?;
+            continue_streaming = true;
 
-                // be a bit tolerant as the timer may not align exactly with time(NULL)
-                if now - locations_last_sent < (60 - 3) {
-                    Ok(None)
-                } else {
-                    Ok(Some((chat_id, locations_send_begin, locations_last_sent)))
-                }
-            },
-            |rows| {
-                rows.filter_map(|v| v.transpose())
-                    .collect::<Result<Vec<_>, _>>()
-                    .map_err(Into::into)
-            },
-        )
-        .await;
-
-    if rows.is_ok() {
+            // be a bit tolerant as the timer may not align exactly with time(NULL)
+            if now - locations_last_sent < (60 - 3) {
+                Ok(None)
+            } else {
+                Ok(Some((chat_id, locations_send_begin, locations_last_sent)))
+            }
+        },
+        |rows| {
+            rows.filter_map(|v| v.transpose())
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(Into::into)
+        },
+    ) {
         let msgs = context
             .sql
-            .with_conn(move |conn| {
-                let rows = rows.unwrap();
-
-                let mut stmt_locations = conn.prepare_cached(
-                    "SELECT id \
+            .prepare(
+                "SELECT id \
                  FROM locations \
                  WHERE from_id=? \
                  AND timestamp>=? \
                  AND timestamp>? \
                  AND independent=0 \
                  ORDER BY timestamp;",
-                )?;
-
-                let mut msgs = Vec::new();
-                for (chat_id, locations_send_begin, locations_last_sent) in &rows {
-                    if !stmt_locations
-                        .exists(paramsv![
-                            DC_CONTACT_ID_SELF,
-                            *locations_send_begin,
-                            *locations_last_sent,
-                        ])
-                        .unwrap_or_default()
-                    {
-                        // if there is no new location, there's nothing to send.
-                        // however, maybe we want to bypass this test eg. 15 minutes
-                    } else {
-                        // pending locations are attached automatically to every message,
-                        // so also to this empty text message.
-                        // DC_CMD_LOCATION is only needed to create a nicer subject.
-                        //
-                        // for optimisation and to avoid flooding the sending queue,
-                        // we could sending these messages only if we're really online.
-                        // the easiest way to determine this, is to check for an empty message queue.
-                        // (might not be 100%, however, as positions are sent combined later
-                        // and dc_set_location() is typically called periodically, this is ok)
-                        let mut msg = Message::new(Viewtype::Text);
-                        msg.hidden = true;
-                        msg.param.set_cmd(SystemMessage::LocationOnly);
-                        msgs.push((*chat_id, msg));
-                    }
-                }
-
-                Ok(msgs)
-            })
-            .await
-            .unwrap_or_default();
+                |mut stmt_locations, _| {
+                    let msgs = rows
+                        .into_iter()
+                        .filter_map(|(chat_id, locations_send_begin, locations_last_sent)| {
+                            if !stmt_locations
+                                .exists(params![
+                                    DC_CONTACT_ID_SELF,
+                                    locations_send_begin,
+                                    locations_last_sent,
+                                ])
+                                .unwrap_or_default()
+                            {
+                                // if there is no new location, there's nothing to send.
+                                // however, maybe we want to bypass this test eg. 15 minutes
+                                None
+                            } else {
+                                // pending locations are attached automatically to every message,
+                                // so also to this empty text message.
+                                // DC_CMD_LOCATION is only needed to create a nicer subject.
+                                //
+                                // for optimisation and to avoid flooding the sending queue,
+                                // we could sending these messages only if we're really online.
+                                // the easiest way to determine this, is to check for an empty message queue.
+                                // (might not be 100%, however, as positions are sent combined later
+                                // and dc_set_location() is typically called periodically, this is ok)
+                                let mut msg = Message::new(Viewtype::Text);
+                                msg.hidden = true;
+                                msg.param.set_cmd(SystemMessage::LocationOnly);
+                                Some((chat_id, msg))
+                            }
+                        })
+                        .collect::<Vec<_>>();
+                    Ok(msgs)
+                },
+            )
+            .unwrap_or_default(); // TODO: Better error handling
 
         for (chat_id, mut msg) in msgs.into_iter() {
             // TODO: better error handling
-            chat::send_msg(context, chat_id, &mut msg)
-                .await
-                .unwrap_or_default();
+            chat::send_msg(context, chat_id, &mut msg).unwrap_or_default();
         }
     }
-
     if continue_streaming {
-        schedule_maybe_send_locations(context, true).await;
+        schedule_MAYBE_SEND_LOCATIONS(context, true);
     }
     job::Status::Finished(Ok(()))
 }
 
-pub(crate) async fn job_maybe_send_locations_ended(
-    context: &Context,
-    job: &mut Job,
-) -> job::Status {
+#[allow(non_snake_case)]
+pub(crate) fn JobMaybeSendLocationsEnded(context: &Context, job: &mut Job) -> job::Status {
     // this function is called when location-streaming _might_ have ended for a chat.
     // the function checks, if location-streaming is really ended;
     // if so, a device-message is added if not yet done.
 
     let chat_id = ChatId::new(job.foreign_id);
 
-    let (send_begin, send_until) = job_try!(
-        context
-            .sql
-            .query_row(
-                "SELECT locations_send_begin, locations_send_until  FROM chats  WHERE id=?",
-                paramsv![chat_id],
-                |row| Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?)),
-            )
-            .await
-    );
+    let (send_begin, send_until) = job_try!(context.sql.query_row(
+        "SELECT locations_send_begin, locations_send_until  FROM chats  WHERE id=?",
+        params![chat_id],
+        |row| Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?)),
+    ));
 
     if !(send_begin != 0 && time() <= send_until) {
         // still streaming -
@@ -706,14 +659,12 @@ pub(crate) async fn job_maybe_send_locations_ended(
             // not streaming, device-message already sent
             job_try!(context.sql.execute(
                 "UPDATE chats    SET locations_send_begin=0, locations_send_until=0  WHERE id=?",
-                paramsv![chat_id],
-            ).await);
+                params![chat_id],
+            ));
 
-            let stock_str = context
-                .stock_system_msg(StockMessage::MsgLocationDisabled, "", "", 0)
-                .await;
-            chat::add_info_msg(context, chat_id, stock_str).await;
-            context.emit_event(Event::ChatModified(chat_id));
+            let stock_str = context.stock_system_msg(StockMessage::MsgLocationDisabled, "", "", 0);
+            chat::add_info_msg(context, chat_id, stock_str);
+            context.call_cb(Event::ChatModified(chat_id));
         }
     }
     job::Status::Finished(Ok(()))
@@ -724,9 +675,9 @@ mod tests {
     use super::*;
     use crate::test_utils::dummy_context;
 
-    #[async_std::test]
-    async fn test_kml_parse() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_kml_parse() {
+        let context = dummy_context();
 
         let xml =
             b"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"user@example.org\">\n<Placemark><Timestamp><when>2019-03-06T21:09:57Z</when></Timestamp><Point><coordinates accuracy=\"32.000000\">9.423110,53.790302</coordinates></Point></Placemark>\n<PlaceMARK>\n<Timestamp><WHEN > \n\t2018-12-13T22:11:12Z\t</WHEN></Timestamp><Point><coordinates aCCuracy=\"2.500000\"> 19.423110 \t , \n 63.790302\n </coordinates></Point></PlaceMARK>\n</Document>\n</kml>";

src/log.rs

@@ -7,7 +7,9 @@ macro_rules! info {
     };
     ($ctx:expr, $msg:expr, $($args:expr),* $(,)?) => {{
         let formatted = format!($msg, $($args),*);
-        let full = format!("{file}:{line}: {msg}",
+        let thread = ::std::thread::current();
+        let full = format!("{thid:?} {file}:{line}: {msg}",
+                           thid = thread.id(),
                            file = file!(),
                            line = line!(),
                            msg = &formatted);
@@ -22,7 +24,9 @@ macro_rules! warn {
     };
     ($ctx:expr, $msg:expr, $($args:expr),* $(,)?) => {{
         let formatted = format!($msg, $($args),*);
-        let full = format!("{file}:{line}: {msg}",
+        let thread = ::std::thread::current();
+        let full = format!("{thid:?} {file}:{line}: {msg}",
+                           thid = thread.id(),
                            file = file!(),
                            line = line!(),
                            msg = &formatted);
@@ -44,6 +48,6 @@ macro_rules! error {
 #[macro_export]
 macro_rules! emit_event {
     ($ctx:expr, $event:expr) => {
-        $ctx.emit_event($event);
+        $ctx.call_cb($event);
     };
 }

src/login_param.rs

@@ -50,69 +50,59 @@ impl LoginParam {
     }
 
     /// Read the login parameters from the database.
-    pub async fn from_database(context: &Context, prefix: impl AsRef<str>) -> Self {
+    pub fn from_database(context: &Context, prefix: impl AsRef<str>) -> Self {
         let prefix = prefix.as_ref();
         let sql = &context.sql;
 
         let key = format!("{}addr", prefix);
         let addr = sql
             .get_raw_config(context, key)
-            .await
             .unwrap_or_default()
             .trim()
             .to_string();
 
         let key = format!("{}mail_server", prefix);
-        let mail_server = sql.get_raw_config(context, key).await.unwrap_or_default();
+        let mail_server = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}mail_port", prefix);
-        let mail_port = sql
-            .get_raw_config_int(context, key)
-            .await
-            .unwrap_or_default();
+        let mail_port = sql.get_raw_config_int(context, key).unwrap_or_default();
 
         let key = format!("{}mail_user", prefix);
-        let mail_user = sql.get_raw_config(context, key).await.unwrap_or_default();
+        let mail_user = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}mail_pw", prefix);
-        let mail_pw = sql.get_raw_config(context, key).await.unwrap_or_default();
+        let mail_pw = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}imap_certificate_checks", prefix);
         let imap_certificate_checks =
-            if let Some(certificate_checks) = sql.get_raw_config_int(context, key).await {
+            if let Some(certificate_checks) = sql.get_raw_config_int(context, key) {
                 num_traits::FromPrimitive::from_i32(certificate_checks).unwrap()
             } else {
                 Default::default()
             };
 
         let key = format!("{}send_server", prefix);
-        let send_server = sql.get_raw_config(context, key).await.unwrap_or_default();
+        let send_server = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}send_port", prefix);
-        let send_port = sql
-            .get_raw_config_int(context, key)
-            .await
-            .unwrap_or_default();
+        let send_port = sql.get_raw_config_int(context, key).unwrap_or_default();
 
         let key = format!("{}send_user", prefix);
-        let send_user = sql.get_raw_config(context, key).await.unwrap_or_default();
+        let send_user = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}send_pw", prefix);
-        let send_pw = sql.get_raw_config(context, key).await.unwrap_or_default();
+        let send_pw = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}smtp_certificate_checks", prefix);
         let smtp_certificate_checks =
-            if let Some(certificate_checks) = sql.get_raw_config_int(context, key).await {
+            if let Some(certificate_checks) = sql.get_raw_config_int(context, key) {
                 num_traits::FromPrimitive::from_i32(certificate_checks).unwrap()
             } else {
                 Default::default()
             };
 
         let key = format!("{}server_flags", prefix);
-        let server_flags = sql
-            .get_raw_config_int(context, key)
-            .await
-            .unwrap_or_default();
+        let server_flags = sql.get_raw_config_int(context, key).unwrap_or_default();
 
         LoginParam {
             addr,
@@ -135,7 +125,7 @@ impl LoginParam {
     }
 
     /// Save this loginparam to the database.
-    pub async fn save_to_database(
+    pub fn save_to_database(
         &self,
         context: &Context,
         prefix: impl AsRef<str>,
@@ -144,49 +134,40 @@ impl LoginParam {
         let sql = &context.sql;
 
         let key = format!("{}addr", prefix);
-        sql.set_raw_config(context, key, Some(&self.addr)).await?;
+        sql.set_raw_config(context, key, Some(&self.addr))?;
 
         let key = format!("{}mail_server", prefix);
-        sql.set_raw_config(context, key, Some(&self.mail_server))
-            .await?;
+        sql.set_raw_config(context, key, Some(&self.mail_server))?;
 
         let key = format!("{}mail_port", prefix);
-        sql.set_raw_config_int(context, key, self.mail_port).await?;
+        sql.set_raw_config_int(context, key, self.mail_port)?;
 
         let key = format!("{}mail_user", prefix);
-        sql.set_raw_config(context, key, Some(&self.mail_user))
-            .await?;
+        sql.set_raw_config(context, key, Some(&self.mail_user))?;
 
         let key = format!("{}mail_pw", prefix);
-        sql.set_raw_config(context, key, Some(&self.mail_pw))
-            .await?;
+        sql.set_raw_config(context, key, Some(&self.mail_pw))?;
 
         let key = format!("{}imap_certificate_checks", prefix);
-        sql.set_raw_config_int(context, key, self.imap_certificate_checks as i32)
-            .await?;
+        sql.set_raw_config_int(context, key, self.imap_certificate_checks as i32)?;
 
         let key = format!("{}send_server", prefix);
-        sql.set_raw_config(context, key, Some(&self.send_server))
-            .await?;
+        sql.set_raw_config(context, key, Some(&self.send_server))?;
 
         let key = format!("{}send_port", prefix);
-        sql.set_raw_config_int(context, key, self.send_port).await?;
+        sql.set_raw_config_int(context, key, self.send_port)?;
 
         let key = format!("{}send_user", prefix);
-        sql.set_raw_config(context, key, Some(&self.send_user))
-            .await?;
+        sql.set_raw_config(context, key, Some(&self.send_user))?;
 
         let key = format!("{}send_pw", prefix);
-        sql.set_raw_config(context, key, Some(&self.send_pw))
-            .await?;
+        sql.set_raw_config(context, key, Some(&self.send_pw))?;
 
         let key = format!("{}smtp_certificate_checks", prefix);
-        sql.set_raw_config_int(context, key, self.smtp_certificate_checks as i32)
-            .await?;
+        sql.set_raw_config_int(context, key, self.smtp_certificate_checks as i32)?;
 
         let key = format!("{}server_flags", prefix);
-        sql.set_raw_config_int(context, key, self.server_flags)
-            .await?;
+        sql.set_raw_config_int(context, key, self.server_flags)?;
 
         Ok(())
     }

src/mimefactory.rs

@@ -66,89 +66,74 @@ pub struct RenderedEmail {
 }
 
 impl<'a, 'b> MimeFactory<'a, 'b> {
-    pub async fn from_msg(
+    pub fn from_msg(
         context: &'a Context,
         msg: &'b Message,
         attach_selfavatar: bool,
     ) -> Result<MimeFactory<'a, 'b>, Error> {
-        let chat = Chat::load_from_db(context, msg.chat_id).await?;
+        let chat = Chat::load_from_db(context, msg.chat_id)?;
 
         let from_addr = context
             .get_config(Config::ConfiguredAddr)
-            .await
-            .unwrap_or_default();
-        let from_displayname = context
-            .get_config(Config::Displayname)
-            .await
             .unwrap_or_default();
+        let from_displayname = context.get_config(Config::Displayname).unwrap_or_default();
         let mut recipients = Vec::with_capacity(5);
         let mut req_mdn = false;
 
         if chat.is_self_talk() {
             recipients.push((from_displayname.to_string(), from_addr.to_string()));
         } else {
-            context
-                .sql
-                .query_map(
-                    "SELECT c.authname, c.addr  \
+            context.sql.query_map(
+                "SELECT c.authname, c.addr  \
                  FROM chats_contacts cc  \
                  LEFT JOIN contacts c ON cc.contact_id=c.id  \
                  WHERE cc.chat_id=? AND cc.contact_id>9;",
-                    paramsv![msg.chat_id],
-                    |row| {
-                        let authname: String = row.get(0)?;
-                        let addr: String = row.get(1)?;
-                        Ok((authname, addr))
-                    },
-                    |rows| {
-                        for row in rows {
-                            let (authname, addr) = row?;
-                            if !recipients_contain_addr(&recipients, &addr) {
-                                recipients.push((authname, addr));
-                            }
+                params![msg.chat_id],
+                |row| {
+                    let authname: String = row.get(0)?;
+                    let addr: String = row.get(1)?;
+                    Ok((authname, addr))
+                },
+                |rows| {
+                    for row in rows {
+                        let (authname, addr) = row?;
+                        if !recipients_contain_addr(&recipients, &addr) {
+                            recipients.push((authname, addr));
                         }
-                        Ok(())
-                    },
-                )
-                .await?;
+                    }
+                    Ok(())
+                },
+            )?;
 
             let command = msg.param.get_cmd();
 
             if command != SystemMessage::AutocryptSetupMessage
                 && command != SystemMessage::SecurejoinMessage
-                && context.get_config_bool(Config::MdnsEnabled).await
+                && context.get_config_bool(Config::MdnsEnabled)
             {
                 req_mdn = true;
             }
         }
-        let (in_reply_to, references) = context
-            .sql
-            .query_row(
-                "SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?",
-                paramsv![msg.id],
-                |row| {
-                    let in_reply_to: String = row.get(0)?;
-                    let references: String = row.get(1)?;
+        let (in_reply_to, references) = context.sql.query_row(
+            "SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?",
+            params![msg.id],
+            |row| {
+                let in_reply_to: String = row.get(0)?;
+                let references: String = row.get(1)?;
 
-                    Ok((
-                        render_rfc724_mid_list(&in_reply_to),
-                        render_rfc724_mid_list(&references),
-                    ))
-                },
-            )
-            .await?;
+                Ok((
+                    render_rfc724_mid_list(&in_reply_to),
+                    render_rfc724_mid_list(&references),
+                ))
+            },
+        )?;
 
-        let default_str = context
-            .stock_str(StockMessage::StatusLine)
-            .await
-            .to_string();
         let factory = MimeFactory {
             from_addr,
             from_displayname,
             selfstatus: context
                 .get_config(Config::Selfstatus)
-                .await
-                .unwrap_or_else(|| default_str),
+                .unwrap_or_else(|| context.stock_str(StockMessage::StatusLine).to_string()),
             recipients,
             timestamp: msg.timestamp_sort,
             loaded: Loaded::Message { chat },
@@ -163,42 +148,29 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         Ok(factory)
     }
 
-    pub async fn from_mdn(
+    pub fn from_mdn(
         context: &'a Context,
         msg: &'b Message,
         additional_msg_ids: Vec<String>,
-    ) -> Result<MimeFactory<'a, 'b>, Error> {
+    ) -> Result<Self, Error> {
         ensure!(!msg.chat_id.is_special(), "Invalid chat id");
 
-        let contact = Contact::load_from_db(context, msg.from_id).await?;
-        let from_addr = context
-            .get_config(Config::ConfiguredAddr)
-            .await
-            .unwrap_or_default();
-        let from_displayname = context
-            .get_config(Config::Displayname)
-            .await
-            .unwrap_or_default();
-        let default_str = context
-            .stock_str(StockMessage::StatusLine)
-            .await
-            .to_string();
-        let selfstatus = context
-            .get_config(Config::Selfstatus)
-            .await
-            .unwrap_or_else(|| default_str);
-        let timestamp = dc_create_smeared_timestamp(context).await;
+        let contact = Contact::load_from_db(context, msg.from_id)?;
 
-        let res = MimeFactory::<'a, 'b> {
+        Ok(MimeFactory {
             context,
-            from_addr,
-            from_displayname,
-            selfstatus,
+            from_addr: context
+                .get_config(Config::ConfiguredAddr)
+                .unwrap_or_default(),
+            from_displayname: context.get_config(Config::Displayname).unwrap_or_default(),
+            selfstatus: context
+                .get_config(Config::Selfstatus)
+                .unwrap_or_else(|| context.stock_str(StockMessage::StatusLine).to_string()),
             recipients: vec![(
                 contact.get_authname().to_string(),
                 contact.get_addr().to_string(),
             )],
-            timestamp,
+            timestamp: dc_create_smeared_timestamp(context),
             loaded: Loaded::MDN { additional_msg_ids },
             msg,
             in_reply_to: String::default(),
@@ -206,31 +178,26 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
             req_mdn: false,
             last_added_location_id: 0,
             attach_selfavatar: false,
-        };
-
-        Ok(res)
+        })
     }
 
-    async fn peerstates_for_recipients(&self) -> Result<Vec<(Option<Peerstate<'_>>, &str)>, Error> {
+    fn peerstates_for_recipients(&self) -> Result<Vec<(Option<Peerstate>, &str)>, Error> {
         let self_addr = self
             .context
             .get_config(Config::ConfiguredAddr)
-            .await
             .ok_or_else(|| format_err!("Not configured"))?;
 
-        let mut res = Vec::new();
-        for (_, addr) in self
+        Ok(self
             .recipients
             .iter()
             .filter(|(_, addr)| addr != &self_addr)
-        {
-            res.push((
-                Peerstate::from_addr(self.context, addr).await,
-                addr.as_str(),
-            ));
-        }
-
-        Ok(res)
+            .map(|(_, addr)| {
+                (
+                    Peerstate::from_addr(self.context, &self.context.sql, addr),
+                    addr.as_str(),
+                )
+            })
+            .collect())
     }
 
     fn is_e2ee_guaranteed(&self) -> bool {
@@ -290,11 +257,11 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         }
     }
 
-    async fn should_do_gossip(&self) -> bool {
+    fn should_do_gossip(&self) -> bool {
         match &self.loaded {
             Loaded::Message { chat } => {
                 // beside key- and member-changes, force re-gossip every 48 hours
-                let gossiped_timestamp = chat.get_gossiped_timestamp(self.context).await;
+                let gossiped_timestamp = chat.get_gossiped_timestamp(self.context);
                 if time() > gossiped_timestamp + (2 * 24 * 60 * 60) {
                     return true;
                 }
@@ -335,13 +302,12 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         }
     }
 
-    async fn subject_str(&self) -> String {
+    fn subject_str(&self) -> String {
         match self.loaded {
             Loaded::Message { ref chat } => {
                 if self.msg.param.get_cmd() == SystemMessage::AutocryptSetupMessage {
                     self.context
                         .stock_str(StockMessage::AcSetupMsgSubject)
-                        .await
                         .into_owned()
                 } else if chat.typ == Chattype::Group || chat.typ == Chattype::VerifiedGroup {
                     let re = if self.in_reply_to.is_empty() {
@@ -357,17 +323,12 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                         &self.msg.param,
                         32,
                         self.context,
-                    )
-                    .await;
+                    );
                     let raw_subject = raw.lines().next().unwrap_or_default();
                     format!("Chat: {}", raw_subject)
                 }
             }
-            Loaded::MDN { .. } => self
-                .context
-                .stock_str(StockMessage::ReadRcpt)
-                .await
-                .into_owned(),
+            Loaded::MDN { .. } => self.context.stock_str(StockMessage::ReadRcpt).into_owned(),
         }
     }
 
@@ -378,7 +339,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
             .collect()
     }
 
-    pub async fn render(mut self) -> Result<RenderedEmail, Error> {
+    pub fn render(mut self) -> Result<RenderedEmail, Error> {
         // Headers that are encrypted
         // - Chat-*, except Chat-Version
         // - Secure-Join*
@@ -461,18 +422,17 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         let min_verified = self.min_verified();
         let grpimage = self.grpimage();
         let force_plaintext = self.should_force_plaintext();
-        let subject_str = self.subject_str().await;
+        let subject_str = self.subject_str();
         let e2ee_guaranteed = self.is_e2ee_guaranteed();
-        let encrypt_helper = EncryptHelper::new(self.context).await?;
+        let mut encrypt_helper = EncryptHelper::new(self.context)?;
 
         let subject = encode_words(&subject_str);
 
         let mut message = match self.loaded {
             Loaded::Message { .. } => {
-                self.render_message(&mut protected_headers, &mut unprotected_headers, &grpimage)
-                    .await?
+                self.render_message(&mut protected_headers, &mut unprotected_headers, &grpimage)?
             }
-            Loaded::MDN { .. } => self.render_mdn().await?,
+            Loaded::MDN { .. } => self.render_mdn()?,
         };
 
         if force_plaintext != ForcePlaintext::NoAutocryptHeader as i32 {
@@ -483,7 +443,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
 
         protected_headers.push(Header::new("Subject".into(), subject));
 
-        let peerstates = self.peerstates_for_recipients().await?;
+        let peerstates = self.peerstates_for_recipients()?;
         let should_encrypt =
             encrypt_helper.should_encrypt(self.context, e2ee_guaranteed, &peerstates)?;
         let is_encrypted = should_encrypt && force_plaintext == 0;
@@ -511,7 +471,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
 
         let outer_message = if is_encrypted {
             // Add gossip headers in chats with multiple recipients
-            if peerstates.len() > 1 && self.should_do_gossip().await {
+            if peerstates.len() > 1 && self.should_do_gossip() {
                 for peerstate in peerstates.iter().filter_map(|(state, _)| state.as_ref()) {
                     if peerstate.peek_key(min_verified).is_some() {
                         if let Some(header) = peerstate.render_gossip_header(min_verified) {
@@ -559,9 +519,8 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                 println!("{}", raw_message);
             }
 
-            let encrypted = encrypt_helper
-                .encrypt(self.context, min_verified, message, peerstates)
-                .await?;
+            let encrypted =
+                encrypt_helper.encrypt(self.context, min_verified, message, &peerstates)?;
 
             outer_message = outer_message
                 .child(
@@ -633,9 +592,9 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         Some(part)
     }
 
-    async fn get_location_kml_part(&mut self) -> Result<PartBuilder, Error> {
+    fn get_location_kml_part(&mut self) -> Result<PartBuilder, Error> {
         let (kml_content, last_added_location_id) =
-            location::get_kml(self.context, self.msg.chat_id).await?;
+            location::get_kml(self.context, self.msg.chat_id)?;
         let part = PartBuilder::new()
             .content_type(
                 &"application/vnd.google-earth.kml+xml"
@@ -655,7 +614,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
     }
 
     #[allow(clippy::cognitive_complexity)]
-    async fn render_message(
+    fn render_message(
         &mut self,
         protected_headers: &mut Vec<Header>,
         unprotected_headers: &mut Vec<Header>,
@@ -750,7 +709,6 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                 placeholdertext = Some(
                     self.context
                         .stock_str(StockMessage::AcSetupMsgBody)
-                        .await
                         .to_string(),
                 );
             }
@@ -797,7 +755,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
             meta.viewtype = Viewtype::Image;
             meta.param.set(Param::File, grpimage);
 
-            let (mail, filename_as_sent) = build_body_file(context, &meta, "group-image").await?;
+            let (mail, filename_as_sent) = build_body_file(context, &meta, "group-image")?;
             meta_part = Some(mail);
             protected_headers.push(Header::new("Chat-Group-Avatar".into(), filename_as_sent));
         }
@@ -868,13 +826,13 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
 
         // add attachment part
         if chat::msgtype_has_file(self.msg.viewtype) {
-            if !is_file_size_okay(context, &self.msg).await {
+            if !is_file_size_okay(context, &self.msg) {
                 bail!(
                     "Message exceeds the recommended {} MB.",
                     RECOMMENDED_FILE_SIZE / 1_000_000,
                 );
             } else {
-                let (file_part, _) = build_body_file(context, &self.msg, "").await?;
+                let (file_part, _) = build_body_file(context, &self.msg, "")?;
                 parts.push(file_part);
             }
         }
@@ -887,8 +845,8 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
             parts.push(msg_kml_part);
         }
 
-        if location::is_sending_locations_to_chat(context, self.msg.chat_id).await {
-            match self.get_location_kml_part().await {
+        if location::is_sending_locations_to_chat(context, self.msg.chat_id) {
+            match self.get_location_kml_part() {
                 Ok(part) => parts.push(part),
                 Err(err) => {
                     warn!(context, "mimefactory: could not send location: {}", err);
@@ -897,7 +855,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         }
 
         if self.attach_selfavatar {
-            match context.get_config(Config::Selfavatar).await {
+            match context.get_config(Config::Selfavatar) {
                 Some(path) => match build_selfavatar_file(context, &path) {
                     Ok((part, filename)) => {
                         parts.push(part);
@@ -924,7 +882,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
     }
 
     /// Render an MDN
-    async fn render_mdn(&mut self) -> Result<PartBuilder, Error> {
+    fn render_mdn(&mut self) -> Result<PartBuilder, Error> {
         // RFC 6522, this also requires the `report-type` parameter which is equal
         // to the MIME subtype of the second body part of the multipart/report
         //
@@ -959,15 +917,13 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         {
             self.context
                 .stock_str(StockMessage::EncryptedMsg)
-                .await
                 .into_owned()
         } else {
-            self.msg.get_summarytext(self.context, 32).await
+            self.msg.get_summarytext(self.context, 32)
         };
         let p2 = self
             .context
-            .stock_string_repl_str(StockMessage::ReadRcptMailBody, p1)
-            .await;
+            .stock_string_repl_str(StockMessage::ReadRcptMailBody, p1);
         let message_text = format!("{}\r\n", p2);
         message = message.child(
             PartBuilder::new()
@@ -1024,15 +980,14 @@ fn wrapped_base64_encode(buf: &[u8]) -> String {
         .join("\r\n")
 }
 
-async fn build_body_file(
+fn build_body_file(
     context: &Context,
     msg: &Message,
     base_name: &str,
 ) -> Result<(PartBuilder, String), Error> {
     let blob = msg
         .param
-        .get_blob(Param::File, context, true)
-        .await?
+        .get_blob(Param::File, context, true)?
         .ok_or_else(|| format_err!("msg has no filename"))?;
     let suffix = blob.suffix().unwrap_or("dat");
 
@@ -1128,10 +1083,10 @@ fn recipients_contain_addr(recipients: &[(String, String)], addr: &str) -> bool
         .any(|(_, cur)| cur.to_lowercase() == addr_lc)
 }
 
-async fn is_file_size_okay(context: &Context, msg: &Message) -> bool {
+fn is_file_size_okay(context: &Context, msg: &Message) -> bool {
     match msg.param.get_path(Param::File, context).unwrap_or(None) {
         Some(path) => {
-            let bytes = dc_get_filebytes(context, &path).await;
+            let bytes = dc_get_filebytes(context, &path);
             bytes <= UPPER_LIMIT_FILE_SIZE
         }
         None => false,

src/mimeparser.rs

@@ -1,6 +1,4 @@
 use std::collections::{HashMap, HashSet};
-use std::future::Future;
-use std::pin::Pin;
 
 use deltachat_derive::{FromSql, ToSql};
 use lettre_email::mime::{self, Mime};
@@ -84,7 +82,7 @@ impl Default for SystemMessage {
 const MIME_AC_SETUP_FILE: &str = "application/autocrypt-setup";
 
 impl MimeMessage {
-    pub async fn from_bytes(context: &Context, body: &[u8]) -> Result<Self> {
+    pub fn from_bytes(context: &Context, body: &[u8]) -> Result<Self> {
         let mail = mailparse::parse_mail(body)?;
 
         let message_time = mail
@@ -115,7 +113,7 @@ impl MimeMessage {
         let mail_raw;
         let mut gossipped_addr = Default::default();
 
-        let (mail, signatures) = match e2ee::try_decrypt(context, &mail, message_time).await {
+        let (mail, signatures) = match e2ee::try_decrypt(context, &mail, message_time) {
             Ok((raw, signatures)) => {
                 if let Some(raw) = raw {
                     // Valid autocrypt message, encrypted
@@ -130,8 +128,7 @@ impl MimeMessage {
                     // "3.6 Key Gossip" of https://autocrypt.org/autocrypt-spec-1.1.0.pdf
                     let gossip_headers = decrypted_mail.headers.get_all_values("Autocrypt-Gossip");
                     gossipped_addr =
-                        update_gossip_peerstates(context, message_time, &mail, gossip_headers)
-                            .await?;
+                        update_gossip_peerstates(context, message_time, &mail, gossip_headers)?;
 
                     // let known protected headers from the decrypted
                     // part override the unencrypted top-level
@@ -182,7 +179,7 @@ impl MimeMessage {
             user_avatar: None,
             group_avatar: None,
         };
-        parser.parse_mime_recursive(context, &mail).await?;
+        parser.parse_mime_recursive(context, &mail)?;
         parser.parse_headers(context)?;
 
         Ok(parser)
@@ -413,69 +410,63 @@ impl MimeMessage {
         self.header.get(headerdef.get_headername())
     }
 
-    fn parse_mime_recursive<'a>(
-        &'a mut self,
-        context: &'a Context,
-        mail: &'a mailparse::ParsedMail<'a>,
-    ) -> Pin<Box<dyn Future<Output = Result<bool>> + 'a + Send>> {
-        use futures::future::FutureExt;
-
-        // Boxed future to deal with recursion
-        async move {
-            if mail.ctype.params.get("protected-headers").is_some() {
-                if mail.ctype.mimetype == "text/rfc822-headers" {
-                    warn!(
-                        context,
-                        "Protected headers found in text/rfc822-headers attachment: Will be ignored.",
-                    );
-                    return Ok(false);
-                }
-
-                warn!(context, "Ignoring nested protected headers");
+    fn parse_mime_recursive(
+        &mut self,
+        context: &Context,
+        mail: &mailparse::ParsedMail<'_>,
+    ) -> Result<bool> {
+        if mail.ctype.params.get("protected-headers").is_some() {
+            if mail.ctype.mimetype == "text/rfc822-headers" {
+                warn!(
+                    context,
+                    "Protected headers found in text/rfc822-headers attachment: Will be ignored.",
+                );
+                return Ok(false);
             }
 
-            enum MimeS {
-                Multiple,
-                Single,
-                Message,
-            }
+            warn!(context, "Ignoring nested protected headers");
+        }
 
-            let mimetype = mail.ctype.mimetype.to_lowercase();
+        enum MimeS {
+            Multiple,
+            Single,
+            Message,
+        }
 
-            let m = if mimetype.starts_with("multipart") {
-                if mail.ctype.params.get("boundary").is_some() {
-                    MimeS::Multiple
-                } else {
-                    MimeS::Single
-                }
-            } else if mimetype.starts_with("message") {
-                if mimetype == "message/rfc822" {
-                    MimeS::Message
-                } else {
-                    MimeS::Single
-                }
+        let mimetype = mail.ctype.mimetype.to_lowercase();
+
+        let m = if mimetype.starts_with("multipart") {
+            if mail.ctype.params.get("boundary").is_some() {
+                MimeS::Multiple
             } else {
                 MimeS::Single
-            };
-
-            match m {
-                MimeS::Multiple => self.handle_multiple(context, mail).await,
-                MimeS::Message => {
-                    let raw = mail.get_body_raw()?;
-                    if raw.is_empty() {
-                        return Ok(false);
-                    }
-                    let mail = mailparse::parse_mail(&raw).unwrap();
-
-                    self.parse_mime_recursive(context, &mail).await
-                }
-                MimeS::Single => self.add_single_part_if_known(context, mail).await,
             }
+        } else if mimetype.starts_with("message") {
+            if mimetype == "message/rfc822" {
+                MimeS::Message
+            } else {
+                MimeS::Single
+            }
+        } else {
+            MimeS::Single
+        };
+
+        match m {
+            MimeS::Multiple => self.handle_multiple(context, mail),
+            MimeS::Message => {
+                let raw = mail.get_body_raw()?;
+                if raw.is_empty() {
+                    return Ok(false);
+                }
+                let mail = mailparse::parse_mail(&raw).unwrap();
+
+                self.parse_mime_recursive(context, &mail)
+            }
+            MimeS::Single => self.add_single_part_if_known(context, mail),
         }
-        .boxed()
     }
 
-    async fn handle_multiple(
+    fn handle_multiple(
         &mut self,
         context: &Context,
         mail: &mailparse::ParsedMail<'_>,
@@ -492,7 +483,7 @@ impl MimeMessage {
                     if get_mime_type(cur_data)?.0 == "multipart/mixed"
                         || get_mime_type(cur_data)?.0 == "multipart/related"
                     {
-                        any_part_added = self.parse_mime_recursive(context, cur_data).await?;
+                        any_part_added = self.parse_mime_recursive(context, cur_data)?;
                         break;
                     }
                 }
@@ -500,7 +491,7 @@ impl MimeMessage {
                     /* search for text/plain and add this */
                     for cur_data in &mail.subparts {
                         if get_mime_type(cur_data)?.0.type_() == mime::TEXT {
-                            any_part_added = self.parse_mime_recursive(context, cur_data).await?;
+                            any_part_added = self.parse_mime_recursive(context, cur_data)?;
                             break;
                         }
                     }
@@ -508,7 +499,7 @@ impl MimeMessage {
                 if !any_part_added {
                     /* `text/plain` not found - use the first part */
                     for cur_part in &mail.subparts {
-                        if self.parse_mime_recursive(context, cur_part).await? {
+                        if self.parse_mime_recursive(context, cur_part)? {
                             any_part_added = true;
                             break;
                         }
@@ -519,7 +510,7 @@ impl MimeMessage {
                 // we currently do not try to decrypt non-autocrypt messages
                 // at all. If we see an encrypted part, we set
                 // decrypting_failed.
-                let msg_body = context.stock_str(StockMessage::CantDecryptMsgBody).await;
+                let msg_body = context.stock_str(StockMessage::CantDecryptMsgBody);
                 let txt = format!("[{}]", msg_body);
 
                 let mut part = Part::default();
@@ -542,7 +533,7 @@ impl MimeMessage {
                 https://k9mail.github.io/2016/11/24/OpenPGP-Considerations-Part-I.html
                 for background information why we use encrypted+signed) */
                 if let Some(first) = mail.subparts.iter().next() {
-                    any_part_added = self.parse_mime_recursive(context, first).await?;
+                    any_part_added = self.parse_mime_recursive(context, first)?;
                 }
             }
             (mime::MULTIPART, "report") => {
@@ -567,7 +558,7 @@ impl MimeMessage {
                             /* eg. `report-type=delivery-status`;
                             maybe we should show them as a little error icon */
                             if let Some(first) = mail.subparts.iter().next() {
-                                any_part_added = self.parse_mime_recursive(context, first).await?;
+                                any_part_added = self.parse_mime_recursive(context, first)?;
                             }
                         }
                     }
@@ -577,7 +568,7 @@ impl MimeMessage {
                 // Add all parts (in fact, AddSinglePartIfKnown() later check if
                 // the parts are really supported)
                 for cur_data in mail.subparts.iter() {
-                    if self.parse_mime_recursive(context, cur_data).await? {
+                    if self.parse_mime_recursive(context, cur_data)? {
                         any_part_added = true;
                     }
                 }
@@ -587,7 +578,7 @@ impl MimeMessage {
         Ok(any_part_added)
     }
 
-    async fn add_single_part_if_known(
+    fn add_single_part_if_known(
         &mut self,
         context: &Context,
         mail: &mailparse::ParsedMail<'_>,
@@ -609,8 +600,7 @@ impl MimeMessage {
                     &raw_mime,
                     &mail.get_body_raw()?,
                     &filename,
-                )
-                .await;
+                );
             }
             None => {
                 match mime_type.type_() {
@@ -662,7 +652,7 @@ impl MimeMessage {
         Ok(self.parts.len() > old_part_count)
     }
 
-    async fn do_add_single_file_part(
+    fn do_add_single_file_part(
         &mut self,
         context: &Context,
         msg_type: Viewtype,
@@ -695,7 +685,7 @@ impl MimeMessage {
         /* we have a regular file attachment,
         write decoded data to new blob object */
 
-        let blob = match BlobObject::create(context, filename, decoded_data).await {
+        let blob = match BlobObject::create(context, filename, decoded_data) {
             Ok(blob) => blob,
             Err(err) => {
                 error!(
@@ -839,7 +829,7 @@ impl MimeMessage {
     }
 
     /// Handle reports (only MDNs for now)
-    pub async fn handle_reports(&self, context: &Context, from_id: u32, sent_timestamp: i64) {
+    pub fn handle_reports(&self, context: &Context, from_id: u32, sent_timestamp: i64) {
         if self.reports.is_empty() {
             return;
         }
@@ -850,16 +840,15 @@ impl MimeMessage {
             {
                 if let Some((chat_id, msg_id)) =
                     message::mdn_from_ext(context, from_id, original_message_id, sent_timestamp)
-                        .await
                 {
-                    context.emit_event(Event::MsgRead { chat_id, msg_id });
+                    context.call_cb(Event::MsgRead { chat_id, msg_id });
                 }
             }
         }
     }
 }
 
-async fn update_gossip_peerstates(
+fn update_gossip_peerstates(
     context: &Context,
     message_time: i64,
     mail: &mailparse::ParsedMail<'_>,
@@ -876,18 +865,18 @@ async fn update_gossip_peerstates(
                 .iter()
                 .any(|info| info.addr == header.addr.to_lowercase())
             {
-                let mut peerstate = Peerstate::from_addr(context, &header.addr).await;
+                let mut peerstate = Peerstate::from_addr(context, &context.sql, &header.addr);
                 if let Some(ref mut peerstate) = peerstate {
                     peerstate.apply_gossip(header, message_time);
-                    peerstate.save_to_db(&context.sql, false).await?;
+                    peerstate.save_to_db(&context.sql, false)?;
                 } else {
                     let p = Peerstate::from_gossip(context, header, message_time);
-                    p.save_to_db(&context.sql, true).await?;
+                    p.save_to_db(&context.sql, true)?;
                     peerstate = Some(p);
                 }
                 if let Some(peerstate) = peerstate {
                     if peerstate.degrade_event.is_some() {
-                        handle_degrade_event(context, &peerstate).await?;
+                        handle_degrade_event(context, &peerstate)?;
                     }
                 }
 
@@ -1115,25 +1104,21 @@ mod tests {
         }
     }
 
-    #[async_std::test]
-    async fn test_dc_mimeparser_crash() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_dc_mimeparser_crash() {
+        let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
-        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         assert_eq!(mimeparser.get_subject(), None);
         assert_eq!(mimeparser.parts.len(), 1);
     }
 
-    #[async_std::test]
-    async fn test_get_rfc724_mid_exists() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_get_rfc724_mid_exists() {
+        let context = dummy_context();
         let raw = include_bytes!("../test-data/message/mail_with_message_id.txt");
-        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         assert_eq!(
             mimeparser.get_rfc724_mid(),
@@ -1141,13 +1126,11 @@ mod tests {
         );
     }
 
-    #[async_std::test]
-    async fn test_get_rfc724_mid_not_exists() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_get_rfc724_mid_not_exists() {
+        let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
-        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.get_rfc724_mid(), None);
     }
 
@@ -1199,9 +1182,9 @@ mod tests {
         );
     }
 
-    #[async_std::test]
-    async fn test_parse_first_addr() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_parse_first_addr() {
+        let context = dummy_context();
         let raw = b"From: hello@one.org, world@two.org\n\
                     Chat-Disposition-Notification-To: wrong\n\
                     Content-Type: text/plain\n\
@@ -1210,9 +1193,7 @@ mod tests {
                     test1\n\
                     ";
 
-        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         let of = &mimeparser.from[0];
         assert_eq!(of.addr, "hello@one.org");
@@ -1220,9 +1201,9 @@ mod tests {
         assert!(mimeparser.chat_disposition_notification_to.is_none());
     }
 
-    #[async_std::test]
-    async fn test_mimeparser_with_context() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_mimeparser_with_context() {
+        let context = dummy_context();
         let raw = b"From: hello\n\
                     Content-Type: multipart/mixed; boundary=\"==break==\";\n\
                     Subject: outer-subject\n\
@@ -1243,9 +1224,7 @@ mod tests {
                     --==break==--\n\
                     \n";
 
-        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         // non-overwritten headers do not bubble up
         let of = mimeparser.get(HeaderDef::SecureJoinGroup).unwrap();
@@ -1270,31 +1249,31 @@ mod tests {
         assert!(mimeparser.get(HeaderDef::SecureJoinFingerprint).is_none());
     }
 
-    #[async_std::test]
-    async fn test_mimeparser_with_avatars() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_mimeparser_with_avatars() {
+        let t = dummy_context();
 
         let raw = include_bytes!("../test-data/message/mail_attach_txt.eml");
-        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).await.unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.user_avatar, None);
         assert_eq!(mimeparser.group_avatar, None);
 
         let raw = include_bytes!("../test-data/message/mail_with_user_avatar.eml");
-        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).await.unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Text);
         assert!(mimeparser.user_avatar.unwrap().is_change());
         assert_eq!(mimeparser.group_avatar, None);
 
         let raw = include_bytes!("../test-data/message/mail_with_user_avatar_deleted.eml");
-        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).await.unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Text);
         assert_eq!(mimeparser.user_avatar, Some(AvatarAction::Delete));
         assert_eq!(mimeparser.group_avatar, None);
 
         let raw = include_bytes!("../test-data/message/mail_with_user_and_group_avatars.eml");
-        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).await.unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Text);
         assert!(mimeparser.user_avatar.unwrap().is_change());
@@ -1304,18 +1283,16 @@ mod tests {
         let raw = include_bytes!("../test-data/message/mail_with_user_and_group_avatars.eml");
         let raw = String::from_utf8_lossy(raw).to_string();
         let raw = raw.replace("Chat-User-Avatar:", "Xhat-Xser-Xvatar:");
-        let mimeparser = MimeMessage::from_bytes(&t.ctx, raw.as_bytes())
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, raw.as_bytes()).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Image);
         assert_eq!(mimeparser.user_avatar, None);
         assert!(mimeparser.group_avatar.unwrap().is_change());
     }
 
-    #[async_std::test]
-    async fn test_mimeparser_message_kml() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_mimeparser_message_kml() {
+        let context = dummy_context();
         let raw = b"Chat-Version: 1.0\n\
 From: foo <foo@example.org>\n\
 To: bar <bar@example.org>\n\
@@ -1343,9 +1320,7 @@ Content-Disposition: attachment; filename=\"message.kml\"\n\
 --==break==--\n\
 ;";
 
-        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(
             mimeparser.get_subject(),
             Some("Location streaming".to_string())
@@ -1358,9 +1333,9 @@ Content-Disposition: attachment; filename=\"message.kml\"\n\
         assert_eq!(mimeparser.parts.len(), 1);
     }
 
-    #[async_std::test]
-    async fn test_parse_mdn() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_parse_mdn() {
+        let context = dummy_context();
         let raw = b"Subject: =?utf-8?q?Chat=3A_Message_opened?=\n\
 Date: Mon, 10 Jan 2020 00:00:00 +0000\n\
 Chat-Version: 1.0\n\
@@ -1392,9 +1367,7 @@ Disposition: manual-action/MDN-sent-automatically; displayed\n\
 --kJBbU58X1xeWNHgBtTbMk80M5qnV4N--\n\
 ";
 
-        let message = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(
             message.get_subject(),
             Some("Chat: Message opened".to_string())
@@ -1408,9 +1381,9 @@ Disposition: manual-action/MDN-sent-automatically; displayed\n\
     ///
     /// RFC 6522 specifically allows MDNs to be nested inside
     /// multipart MIME messages.
-    #[async_std::test]
-    async fn test_parse_multiple_mdns() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_parse_multiple_mdns() {
+        let context = dummy_context();
         let raw = b"Subject: =?utf-8?q?Chat=3A_Message_opened?=\n\
 Date: Mon, 10 Jan 2020 00:00:00 +0000\n\
 Chat-Version: 1.0\n\
@@ -1472,9 +1445,7 @@ Disposition: manual-action/MDN-sent-automatically; displayed\n\
 --outer--\n\
 ";
 
-        let message = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(
             message.get_subject(),
             Some("Chat: Message opened".to_string())
@@ -1484,9 +1455,9 @@ Disposition: manual-action/MDN-sent-automatically; displayed\n\
         assert_eq!(message.reports.len(), 2);
     }
 
-    #[async_std::test]
-    async fn test_parse_mdn_with_additional_message_ids() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_parse_mdn_with_additional_message_ids() {
+        let context = dummy_context();
         let raw = b"Subject: =?utf-8?q?Chat=3A_Message_opened?=\n\
 Date: Mon, 10 Jan 2020 00:00:00 +0000\n\
 Chat-Version: 1.0\n\
@@ -1519,9 +1490,7 @@ Additional-Message-IDs: <foo@example.com> <foo@example.net>\n\
 --kJBbU58X1xeWNHgBtTbMk80M5qnV4N--\n\
 ";
 
-        let message = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(
             message.get_subject(),
             Some("Chat: Message opened".to_string())
@@ -1536,9 +1505,9 @@ Additional-Message-IDs: <foo@example.com> <foo@example.net>\n\
         );
     }
 
-    #[async_std::test]
-    async fn test_parse_inline_attachment() {
-        let context = dummy_context().await;
+    #[test]
+    fn test_parse_inline_attachment() {
+        let context = dummy_context();
         let raw = br#"Date: Thu, 13 Feb 2020 22:41:20 +0000 (UTC)
 From: sender@example.com
 To: receiver@example.com
@@ -1563,9 +1532,7 @@ MDYyMDYxNTE1RTlDOEE4Cj4+CnN0YXJ0eHJlZgo4Mjc4CiUlRU9GCg==
 ------=_Part_25_46172632.1581201680436--
 "#;
 
-        let message = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(
             message.get_subject(),
             Some("Mail with inline attachment".to_string())
@@ -1576,9 +1543,9 @@ MDYyMDYxNTE1RTlDOEE4Cj4+CnN0YXJ0eHJlZgo4Mjc4CiUlRU9GCg==
         assert_eq!(message.parts[0].msg, "Hello!");
     }
 
-    #[async_std::test]
-    async fn parse_inline_image() {
-        let context = dummy_context().await;
+    #[test]
+    fn parse_inline_image() {
+        let context = dummy_context();
         let raw = br#"Message-ID: <foobar@example.org>
 From: foo <foo@example.org>
 Subject: example
@@ -1612,9 +1579,7 @@ CWt6wx7fiLp0qS9RrX75g6Gqw7nfCs6EcBERcIPt7DTe8VStJwf3LWqVwxl4gQl46yhfoqwEO+I=
 ----11019878869865180--
 "#;
 
-        let message = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(message.get_subject(), Some("example".to_string()));
 
         assert_eq!(message.parts.len(), 1);
@@ -1622,9 +1587,9 @@ CWt6wx7fiLp0qS9RrX75g6Gqw7nfCs6EcBERcIPt7DTe8VStJwf3LWqVwxl4gQl46yhfoqwEO+I=
         assert_eq!(message.parts[0].msg, "Test");
     }
 
-    #[async_std::test]
-    async fn parse_thunderbird_html_embedded_image() {
-        let context = dummy_context().await;
+    #[test]
+    fn parse_thunderbird_html_embedded_image() {
+        let context = dummy_context();
         let raw = br#"To: Alice <alice@example.org>
 From: Bob <bob@example.org>
 Subject: Test subject
@@ -1684,9 +1649,7 @@ CWt6wx7fiLp0qS9RrX75g6Gqw7nfCs6EcBERcIPt7DTe8VStJwf3LWqVwxl4gQl46yhfoqwEO+I=
 
 --------------779C1631600DF3DB8C02E53A--"#;
 
-        let message = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(message.get_subject(), Some("Test subject".to_string()));
 
         assert_eq!(message.parts.len(), 1);
@@ -1695,9 +1658,9 @@ CWt6wx7fiLp0qS9RrX75g6Gqw7nfCs6EcBERcIPt7DTe8VStJwf3LWqVwxl4gQl46yhfoqwEO+I=
     }
 
     // Outlook specifies filename in the "name" attribute of Content-Type
-    #[async_std::test]
-    async fn parse_outlook_html_embedded_image() {
-        let context = dummy_context().await;
+    #[test]
+    fn parse_outlook_html_embedded_image() {
+        let context = dummy_context();
         let raw = br##"From: Anonymous <anonymous@example.org>
 To: Anonymous <anonymous@example.org>
 Subject: Delta Chat is great stuff!
@@ -1755,9 +1718,7 @@ CWt6wx7fiLp0qS9RrX75g6Gqw7nfCs6EcBERcIPt7DTe8VStJwf3LWqVwxl4gQl46yhfoqwEO+I=
 ------=_NextPart_000_0003_01D622B3.CA753E60--
 "##;
 
-        let message = MimeMessage::from_bytes(&context.ctx, &raw[..])
-            .await
-            .unwrap();
+        let message = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(
             message.get_subject(),
             Some("Delta Chat is great stuff!".to_string())

src/oauth2.rs

@@ -48,7 +48,7 @@ struct Response {
     scope: Option<String>,
 }
 
-pub async fn dc_get_oauth2_url(
+pub fn dc_get_oauth2_url(
     context: &Context,
     addr: impl AsRef<str>,
     redirect_uri: impl AsRef<str>,
@@ -61,7 +61,6 @@ pub async fn dc_get_oauth2_url(
                 "oauth2_pending_redirect_uri",
                 Some(redirect_uri.as_ref()),
             )
-            .await
             .is_err()
         {
             return None;
@@ -75,21 +74,21 @@ pub async fn dc_get_oauth2_url(
     }
 }
 
-pub async fn dc_get_oauth2_access_token(
+// The following function may block due http-requests;
+// must not be called from the main thread or by the ui!
+pub fn dc_get_oauth2_access_token(
     context: &Context,
     addr: impl AsRef<str>,
     code: impl AsRef<str>,
     regenerate: bool,
 ) -> Option<String> {
     if let Some(oauth2) = Oauth2::from_address(addr) {
-        let lock = context.oauth2_mutex.lock().await;
+        let lock = context.oauth2_critical.clone();
+        let _l = lock.lock().unwrap();
 
         // read generated token
-        if !regenerate && !is_expired(context).await {
-            let access_token = context
-                .sql
-                .get_raw_config(context, "oauth2_access_token")
-                .await;
+        if !regenerate && !is_expired(context) {
+            let access_token = context.sql.get_raw_config(context, "oauth2_access_token");
             if access_token.is_some() {
                 // success
                 return access_token;
@@ -97,14 +96,10 @@ pub async fn dc_get_oauth2_access_token(
         }
 
         // generate new token: build & call auth url
-        let refresh_token = context
-            .sql
-            .get_raw_config(context, "oauth2_refresh_token")
-            .await;
+        let refresh_token = context.sql.get_raw_config(context, "oauth2_refresh_token");
         let refresh_token_for = context
             .sql
             .get_raw_config(context, "oauth2_refresh_token_for")
-            .await
             .unwrap_or_else(|| "unset".into());
 
         let (redirect_uri, token_url, update_redirect_uri_on_success) =
@@ -114,7 +109,6 @@ pub async fn dc_get_oauth2_access_token(
                     context
                         .sql
                         .get_raw_config(context, "oauth2_pending_redirect_uri")
-                        .await
                         .unwrap_or_else(|| "unset".into()),
                     oauth2.init_token,
                     true,
@@ -128,7 +122,6 @@ pub async fn dc_get_oauth2_access_token(
                     context
                         .sql
                         .get_raw_config(context, "oauth2_redirect_uri")
-                        .await
                         .unwrap_or_else(|| "unset".into()),
                     oauth2.refresh_token,
                     false,
@@ -161,7 +154,10 @@ pub async fn dc_get_oauth2_access_token(
         }
 
         // ... and POST
-        let response = surf::post(post_url).body_form(&post_param);
+        let response = reqwest::blocking::Client::new()
+            .post(post_url)
+            .form(&post_param)
+            .send();
         if response.is_err() {
             warn!(
                 context,
@@ -169,8 +165,19 @@ pub async fn dc_get_oauth2_access_token(
             );
             return None;
         }
+        let response = response.unwrap();
+        if !response.status().is_success() {
+            warn!(
+                context,
+                "Unsuccessful response when calling OAuth2 at {}: {:?}",
+                token_url,
+                response.status()
+            );
+            return None;
+        }
 
-        let parsed: Result<Response, _> = response.unwrap().recv_json().await;
+        // generate new token: parse returned json
+        let parsed: reqwest::Result<Response> = response.json();
         if parsed.is_err() {
             warn!(
                 context,
@@ -178,6 +185,7 @@ pub async fn dc_get_oauth2_access_token(
             );
             return None;
         }
+        println!("response: {:?}", &parsed);
 
         // update refresh_token if given, typically on the first round, but we update it later as well.
         let response = parsed.unwrap();
@@ -185,12 +193,10 @@ pub async fn dc_get_oauth2_access_token(
             context
                 .sql
                 .set_raw_config(context, "oauth2_refresh_token", Some(token))
-                .await
                 .ok();
             context
                 .sql
                 .set_raw_config(context, "oauth2_refresh_token_for", Some(code.as_ref()))
-                .await
                 .ok();
         }
 
@@ -200,7 +206,6 @@ pub async fn dc_get_oauth2_access_token(
             context
                 .sql
                 .set_raw_config(context, "oauth2_access_token", Some(token))
-                .await
                 .ok();
             let expires_in = response
                 .expires_in
@@ -210,22 +215,18 @@ pub async fn dc_get_oauth2_access_token(
             context
                 .sql
                 .set_raw_config_int64(context, "oauth2_timestamp_expires", expires_in)
-                .await
                 .ok();
 
             if update_redirect_uri_on_success {
                 context
                     .sql
                     .set_raw_config(context, "oauth2_redirect_uri", Some(redirect_uri.as_ref()))
-                    .await
                     .ok();
             }
         } else {
             warn!(context, "Failed to find OAuth2 access token");
         }
 
-        drop(lock);
-
         response.access_token
     } else {
         warn!(context, "Internal OAuth2 error: 2");
@@ -234,7 +235,7 @@ pub async fn dc_get_oauth2_access_token(
     }
 }
 
-pub async fn dc_get_oauth2_addr(
+pub fn dc_get_oauth2_addr(
     context: &Context,
     addr: impl AsRef<str>,
     code: impl AsRef<str>,
@@ -243,14 +244,13 @@ pub async fn dc_get_oauth2_addr(
     oauth2.get_userinfo?;
 
     if let Some(access_token) =
-        dc_get_oauth2_access_token(context, addr.as_ref(), code.as_ref(), false).await
+        dc_get_oauth2_access_token(context, addr.as_ref(), code.as_ref(), false)
     {
-        let addr_out = oauth2.get_addr(context, access_token).await;
+        let addr_out = oauth2.get_addr(context, access_token);
         if addr_out.is_none() {
             // regenerate
-            if let Some(access_token) = dc_get_oauth2_access_token(context, addr, code, true).await
-            {
-                oauth2.get_addr(context, access_token).await
+            if let Some(access_token) = dc_get_oauth2_access_token(context, addr, code, true) {
+                oauth2.get_addr(context, access_token)
             } else {
                 None
             }
@@ -280,7 +280,7 @@ impl Oauth2 {
         }
     }
 
-    async fn get_addr(&self, context: &Context, access_token: impl AsRef<str>) -> Option<String> {
+    fn get_addr(&self, context: &Context, access_token: impl AsRef<str>) -> Option<String> {
         let userinfo_url = self.get_userinfo.unwrap_or_else(|| "");
         let userinfo_url = replace_in_uri(&userinfo_url, "$ACCESS_TOKEN", access_token);
 
@@ -291,35 +291,50 @@ impl Oauth2 {
         //   "verified_email": true,
         //   "picture": "https://lh4.googleusercontent.com/-Gj5jh_9R0BY/AAAAAAAAAAI/AAAAAAAAAAA/IAjtjfjtjNA/photo.jpg"
         // }
-        let response: Result<HashMap<String, serde_json::Value>, surf::Error> =
-            surf::get(userinfo_url).recv_json().await;
+        let response = reqwest::blocking::Client::new().get(&userinfo_url).send();
         if response.is_err() {
             warn!(context, "Error getting userinfo: {:?}", response);
             return None;
         }
+        let response = response.unwrap();
+        if !response.status().is_success() {
+            warn!(context, "Error getting userinfo: {:?}", response.status());
+            return None;
+        }
 
-        let parsed = response.unwrap();
-        // CAVE: serde_json::Value.as_str() removes the quotes of json-strings
-        // but serde_json::Value.to_string() does not!
-        if let Some(addr) = parsed.get("email") {
-            if let Some(s) = addr.as_str() {
-                Some(s.to_string())
+        let parsed: reqwest::Result<HashMap<String, serde_json::Value>> = response.json();
+        if parsed.is_err() {
+            warn!(
+                context,
+                "Failed to parse userinfo JSON response: {:?}", parsed
+            );
+            return None;
+        }
+        if let Ok(response) = parsed {
+            // CAVE: serde_json::Value.as_str() removes the quotes of json-strings
+            // but serde_json::Value.to_string() does not!
+            if let Some(addr) = response.get("email") {
+                if let Some(s) = addr.as_str() {
+                    Some(s.to_string())
+                } else {
+                    warn!(context, "E-mail in userinfo is not a string: {}", addr);
+                    None
+                }
             } else {
-                warn!(context, "E-mail in userinfo is not a string: {}", addr);
+                warn!(context, "E-mail missing in userinfo.");
                 None
             }
         } else {
-            warn!(context, "E-mail missing in userinfo.");
+            warn!(context, "Failed to parse userinfo.");
             None
         }
     }
 }
 
-async fn is_expired(context: &Context) -> bool {
+fn is_expired(context: &Context) -> bool {
     let expire_timestamp = context
         .sql
         .get_raw_config_int64(context, "oauth2_timestamp_expires")
-        .await
         .unwrap_or_default();
 
     if expire_timestamp <= 0 {
@@ -378,32 +393,32 @@ mod tests {
         assert_eq!(Oauth2::from_address("hello@web.de"), None);
     }
 
-    #[async_std::test]
-    async fn test_dc_get_oauth2_addr() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_dc_get_oauth2_addr() {
+        let ctx = dummy_context();
         let addr = "dignifiedquire@gmail.com";
         let code = "fail";
-        let res = dc_get_oauth2_addr(&ctx.ctx, addr, code).await;
+        let res = dc_get_oauth2_addr(&ctx.ctx, addr, code);
         // this should fail as it is an invalid password
         assert_eq!(res, None);
     }
 
-    #[async_std::test]
-    async fn test_dc_get_oauth2_url() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_dc_get_oauth2_url() {
+        let ctx = dummy_context();
         let addr = "dignifiedquire@gmail.com";
         let redirect_uri = "chat.delta:/com.b44t.messenger";
-        let res = dc_get_oauth2_url(&ctx.ctx, addr, redirect_uri).await;
+        let res = dc_get_oauth2_url(&ctx.ctx, addr, redirect_uri);
 
         assert_eq!(res, Some("https://accounts.google.com/o/oauth2/auth?client_id=959970109878%2D4mvtgf6feshskf7695nfln6002mom908%2Eapps%2Egoogleusercontent%2Ecom&redirect_uri=chat%2Edelta%3A%2Fcom%2Eb44t%2Emessenger&response_type=code&scope=https%3A%2F%2Fmail.google.com%2F%20email&access_type=offline".into()));
     }
 
-    #[async_std::test]
-    async fn test_dc_get_oauth2_token() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_dc_get_oauth2_token() {
+        let ctx = dummy_context();
         let addr = "dignifiedquire@gmail.com";
         let code = "fail";
-        let res = dc_get_oauth2_access_token(&ctx.ctx, addr, code, false).await;
+        let res = dc_get_oauth2_access_token(&ctx.ctx, addr, code, false);
         // this should fail as it is an invalid password
         assert_eq!(res, None);
     }

src/param.rs

@@ -1,8 +1,8 @@
 use std::collections::BTreeMap;
 use std::fmt;
+use std::path::PathBuf;
 use std::str;
 
-use async_std::path::PathBuf;
 use num_traits::FromPrimitive;
 use serde::{Deserialize, Serialize};
 
@@ -275,8 +275,7 @@ impl Params {
     /// created without copying if the path already referes to a valid
     /// blob.  If so a [BlobObject] will be returned regardless of the
     /// `create` argument.
-    #[allow(clippy::needless_lifetimes)]
-    pub async fn get_blob<'a>(
+    pub fn get_blob<'a>(
         &self,
         key: Param,
         context: &'a Context,
@@ -289,7 +288,7 @@ impl Params {
         let file = ParamsFile::from_param(context, val)?;
         let blob = match file {
             ParamsFile::FsPath(path) => match create {
-                true => BlobObject::new_from_path(context, path).await?,
+                true => BlobObject::new_from_path(context, path)?,
                 false => BlobObject::from_path(context, path)?,
             },
             ParamsFile::Blob(blob) => blob,
@@ -363,8 +362,8 @@ impl<'a> ParamsFile<'a> {
 mod tests {
     use super::*;
 
-    use async_std::fs;
-    use async_std::path::Path;
+    use std::fs;
+    use std::path::Path;
 
     use crate::test_utils::*;
 
@@ -412,9 +411,9 @@ mod tests {
         assert_eq!(p1.get(Param::Forwarded).unwrap(), "cli%40deltachat.de");
     }
 
-    #[async_std::test]
-    async fn test_params_file_fs_path() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_params_file_fs_path() {
+        let t = dummy_context();
         if let ParamsFile::FsPath(p) = ParamsFile::from_param(&t.ctx, "/foo/bar/baz").unwrap() {
             assert_eq!(p, Path::new("/foo/bar/baz"));
         } else {
@@ -422,9 +421,9 @@ mod tests {
         }
     }
 
-    #[async_std::test]
-    async fn test_params_file_blob() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_params_file_blob() {
+        let t = dummy_context();
         if let ParamsFile::Blob(b) = ParamsFile::from_param(&t.ctx, "$BLOBDIR/foo").unwrap() {
             assert_eq!(b.as_name(), "$BLOBDIR/foo");
         } else {
@@ -433,33 +432,28 @@ mod tests {
     }
 
     // Tests for Params::get_file(), Params::get_path() and Params::get_blob().
-    #[async_std::test]
-    async fn test_params_get_fileparam() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_params_get_fileparam() {
+        let t = dummy_context();
         let fname = t.dir.path().join("foo");
         let mut p = Params::new();
         p.set(Param::File, fname.to_str().unwrap());
 
         let file = p.get_file(Param::File, &t.ctx).unwrap().unwrap();
-        assert_eq!(file, ParamsFile::FsPath(fname.clone().into()));
+        assert_eq!(file, ParamsFile::FsPath(fname.clone()));
 
-        let path: PathBuf = p.get_path(Param::File, &t.ctx).unwrap().unwrap();
-        let fname: PathBuf = fname.into();
+        let path = p.get_path(Param::File, &t.ctx).unwrap().unwrap();
         assert_eq!(path, fname);
 
         // Blob does not exist yet, expect BlobError.
-        let err = p.get_blob(Param::File, &t.ctx, false).await.unwrap_err();
+        let err = p.get_blob(Param::File, &t.ctx, false).unwrap_err();
         match err {
             BlobError::WrongBlobdir { .. } => (),
             _ => panic!("wrong error type/variant: {:?}", err),
         }
 
-        fs::write(fname, b"boo").await.unwrap();
-        let blob = p
-            .get_blob(Param::File, &t.ctx, true)
-            .await
-            .unwrap()
-            .unwrap();
+        fs::write(fname, b"boo").unwrap();
+        let blob = p.get_blob(Param::File, &t.ctx, true).unwrap().unwrap();
         assert_eq!(
             blob,
             BlobObject::from_name(&t.ctx, "foo".to_string()).unwrap()
@@ -468,11 +462,7 @@ mod tests {
         // Blob in blobdir, expect blob.
         let bar = t.ctx.get_blobdir().join("bar");
         p.set(Param::File, bar.to_str().unwrap());
-        let blob = p
-            .get_blob(Param::File, &t.ctx, false)
-            .await
-            .unwrap()
-            .unwrap();
+        let blob = p.get_blob(Param::File, &t.ctx, false).unwrap().unwrap();
         assert_eq!(
             blob,
             BlobObject::from_name(&t.ctx, "bar".to_string()).unwrap()
@@ -481,10 +471,6 @@ mod tests {
         p.remove(Param::File);
         assert!(p.get_file(Param::File, &t.ctx).unwrap().is_none());
         assert!(p.get_path(Param::File, &t.ctx).unwrap().is_none());
-        assert!(p
-            .get_blob(Param::File, &t.ctx, false)
-            .await
-            .unwrap()
-            .is_none());
+        assert!(p.get_blob(Param::File, &t.ctx, false).unwrap().is_none());
     }
 }

src/peerstate.rs

@@ -6,9 +6,10 @@ use std::fmt;
 use num_traits::FromPrimitive;
 
 use crate::aheader::*;
+use crate::constants::*;
 use crate::context::Context;
-use crate::key::{DcKey, SignedPublicKey};
-use crate::sql::Sql;
+use crate::key::{Key, SignedPublicKey};
+use crate::sql::{self, Sql};
 
 #[derive(Debug)]
 pub enum PeerstateKeyType {
@@ -31,12 +32,12 @@ pub struct Peerstate<'a> {
     pub last_seen: i64,
     pub last_seen_autocrypt: i64,
     pub prefer_encrypt: EncryptPreference,
-    pub public_key: Option<SignedPublicKey>,
+    pub public_key: Option<Key>,
     pub public_key_fingerprint: Option<String>,
-    pub gossip_key: Option<SignedPublicKey>,
+    pub gossip_key: Option<Key>,
     pub gossip_timestamp: i64,
     pub gossip_key_fingerprint: Option<String>,
-    pub verified_key: Option<SignedPublicKey>,
+    pub verified_key: Option<Key>,
     pub verified_key_fingerprint: Option<String>,
     pub to_save: Option<ToSave>,
     pub degrade_event: Option<DegradeEvent>,
@@ -126,7 +127,7 @@ impl<'a> Peerstate<'a> {
         res.last_seen_autocrypt = message_time;
         res.to_save = Some(ToSave::All);
         res.prefer_encrypt = header.prefer_encrypt;
-        res.public_key = Some(header.public_key.clone());
+        res.public_key = Some(Key::from(header.public_key.clone()));
         res.recalc_fingerprint();
 
         res
@@ -137,22 +138,18 @@ impl<'a> Peerstate<'a> {
 
         res.gossip_timestamp = message_time;
         res.to_save = Some(ToSave::All);
-        res.gossip_key = Some(gossip_header.public_key.clone());
+        res.gossip_key = Some(Key::from(gossip_header.public_key.clone()));
         res.recalc_fingerprint();
 
         res
     }
 
-    pub async fn from_addr(context: &'a Context, addr: &str) -> Option<Peerstate<'a>> {
+    pub fn from_addr(context: &'a Context, _sql: &Sql, addr: &str) -> Option<Self> {
         let query = "SELECT addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint FROM acpeerstates  WHERE addr=? COLLATE NOCASE;";
-        Self::from_stmt(context, query, paramsv![addr]).await
+        Self::from_stmt(context, query, &[addr])
     }
 
-    pub async fn from_fingerprint(
-        context: &'a Context,
-        _sql: &Sql,
-        fingerprint: &str,
-    ) -> Option<Peerstate<'a>> {
+    pub fn from_fingerprint(context: &'a Context, _sql: &Sql, fingerprint: &str) -> Option<Self> {
         let query = "SELECT addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, \
                      gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, \
                      verified_key, verified_key_fingerprint \
@@ -164,16 +161,15 @@ impl<'a> Peerstate<'a> {
         Self::from_stmt(
             context,
             query,
-            paramsv![fingerprint, fingerprint, fingerprint],
+            params![fingerprint, fingerprint, fingerprint],
         )
-        .await
     }
 
-    async fn from_stmt(
-        context: &'a Context,
-        query: &str,
-        params: Vec<&dyn crate::ToSql>,
-    ) -> Option<Peerstate<'a>> {
+    fn from_stmt<P>(context: &'a Context, query: &str, params: P) -> Option<Self>
+    where
+        P: IntoIterator,
+        P::Item: rusqlite::ToSql,
+    {
         context
             .sql
             .query_row(query, params, |row| {
@@ -219,26 +215,25 @@ impl<'a> Peerstate<'a> {
                 res.public_key = row
                     .get(4)
                     .ok()
-                    .and_then(|blob: Vec<u8>| SignedPublicKey::from_slice(&blob).ok());
+                    .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
                 res.gossip_key = row
                     .get(6)
                     .ok()
-                    .and_then(|blob: Vec<u8>| SignedPublicKey::from_slice(&blob).ok());
+                    .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
                 res.verified_key = row
                     .get(9)
                     .ok()
-                    .and_then(|blob: Vec<u8>| SignedPublicKey::from_slice(&blob).ok());
+                    .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
 
                 Ok(res)
             })
-            .await
             .ok()
     }
 
     pub fn recalc_fingerprint(&mut self) {
         if let Some(ref public_key) = self.public_key {
             let old_public_fingerprint = self.public_key_fingerprint.take();
-            self.public_key_fingerprint = Some(public_key.fingerprint().hex());
+            self.public_key_fingerprint = Some(public_key.fingerprint());
 
             if old_public_fingerprint.is_none()
                 || self.public_key_fingerprint.is_none()
@@ -253,7 +248,7 @@ impl<'a> Peerstate<'a> {
 
         if let Some(ref gossip_key) = self.gossip_key {
             let old_gossip_fingerprint = self.gossip_key_fingerprint.take();
-            self.gossip_key_fingerprint = Some(gossip_key.fingerprint().hex());
+            self.gossip_key_fingerprint = Some(gossip_key.fingerprint());
 
             if old_gossip_fingerprint.is_none()
                 || self.gossip_key_fingerprint.is_none()
@@ -299,8 +294,8 @@ impl<'a> Peerstate<'a> {
                 self.to_save = Some(ToSave::All)
             }
 
-            if self.public_key.as_ref() != Some(&header.public_key) {
-                self.public_key = Some(header.public_key.clone());
+            if self.public_key.as_ref() != Some(&Key::from(header.public_key.clone())) {
+                self.public_key = Some(Key::from(header.public_key.clone()));
                 self.recalc_fingerprint();
                 self.to_save = Some(ToSave::All);
             }
@@ -315,8 +310,9 @@ impl<'a> Peerstate<'a> {
         if message_time > self.gossip_timestamp {
             self.gossip_timestamp = message_time;
             self.to_save = Some(ToSave::Timestamps);
-            if self.gossip_key.as_ref() != Some(&gossip_header.public_key) {
-                self.gossip_key = Some(gossip_header.public_key.clone());
+            let hdr_key = Key::from(gossip_header.public_key.clone());
+            if self.gossip_key.as_ref() != Some(&hdr_key) {
+                self.gossip_key = Some(hdr_key);
                 self.recalc_fingerprint();
                 self.to_save = Some(ToSave::All)
             }
@@ -365,16 +361,7 @@ impl<'a> Peerstate<'a> {
         }
     }
 
-    pub fn take_key(mut self, min_verified: PeerstateVerifiedStatus) -> Option<SignedPublicKey> {
-        match min_verified {
-            PeerstateVerifiedStatus::BidirectVerified => self.verified_key.take(),
-            PeerstateVerifiedStatus::Unverified => {
-                self.public_key.take().or_else(|| self.gossip_key.take())
-            }
-        }
-    }
-
-    pub fn peek_key(&self, min_verified: PeerstateVerifiedStatus) -> Option<&SignedPublicKey> {
+    pub fn peek_key(&self, min_verified: PeerstateVerifiedStatus) -> Option<&Key> {
         match min_verified {
             PeerstateVerifiedStatus::BidirectVerified => self.verified_key.as_ref(),
             PeerstateVerifiedStatus::Unverified => self
@@ -422,48 +409,52 @@ impl<'a> Peerstate<'a> {
         }
     }
 
-    pub async fn save_to_db(&self, sql: &Sql, create: bool) -> crate::sql::Result<()> {
+    pub fn save_to_db(&self, sql: &Sql, create: bool) -> crate::sql::Result<()> {
         if create {
-            sql.execute(
+            sql::execute(
+                self.context,
+                sql,
                 "INSERT INTO acpeerstates (addr) VALUES(?);",
-                paramsv![self.addr],
-            )
-            .await?;
+                params![self.addr],
+            )?;
         }
 
         if self.to_save == Some(ToSave::All) || create {
-            sql.execute(
+            sql::execute(
+                self.context,
+                sql,
                 "UPDATE acpeerstates \
                  SET last_seen=?, last_seen_autocrypt=?, prefer_encrypted=?, \
                  public_key=?, gossip_timestamp=?, gossip_key=?, public_key_fingerprint=?, gossip_key_fingerprint=?, \
                  verified_key=?, verified_key_fingerprint=? \
                  WHERE addr=?;",
-                paramsv![
+                params![
                     self.last_seen,
                     self.last_seen_autocrypt,
                     self.prefer_encrypt as i64,
                     self.public_key.as_ref().map(|k| k.to_bytes()),
                     self.gossip_timestamp,
                     self.gossip_key.as_ref().map(|k| k.to_bytes()),
-                    self.public_key_fingerprint,
-                    self.gossip_key_fingerprint,
+                    &self.public_key_fingerprint,
+                    &self.gossip_key_fingerprint,
                     self.verified_key.as_ref().map(|k| k.to_bytes()),
-                    self.verified_key_fingerprint,
-                    self.addr,
+                    &self.verified_key_fingerprint,
+                    &self.addr,
                 ],
-            ).await?;
+            )?;
         } else if self.to_save == Some(ToSave::Timestamps) {
-            sql.execute(
+            sql::execute(
+                self.context,
+                sql,
                 "UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? \
                  WHERE addr=?;",
-                paramsv![
+                params![
                     self.last_seen,
                     self.last_seen_autocrypt,
                     self.gossip_timestamp,
-                    self.addr
+                    &self.addr
                 ],
-            )
-            .await?;
+            )?;
         }
 
         Ok(())
@@ -488,12 +479,12 @@ mod tests {
     use pretty_assertions::assert_eq;
     use tempfile::TempDir;
 
-    #[async_std::test]
-    async fn test_peerstate_save_to_db() {
-        let ctx = crate::test_utils::dummy_context().await;
+    #[test]
+    fn test_peerstate_save_to_db() {
+        let ctx = crate::test_utils::dummy_context();
         let addr = "hello@mail.com";
 
-        let pub_key = alice_keypair().public;
+        let pub_key = crate::key::Key::from(alice_keypair().public);
 
         let mut peerstate = Peerstate {
             context: &ctx.ctx,
@@ -502,40 +493,38 @@ mod tests {
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.fingerprint().hex()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: Some(pub_key.clone()),
             gossip_timestamp: 12,
-            gossip_key_fingerprint: Some(pub_key.fingerprint().hex()),
+            gossip_key_fingerprint: Some(pub_key.fingerprint()),
             verified_key: Some(pub_key.clone()),
-            verified_key_fingerprint: Some(pub_key.fingerprint().hex()),
+            verified_key_fingerprint: Some(pub_key.fingerprint()),
             to_save: Some(ToSave::All),
             degrade_event: None,
         };
 
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
             "failed to save to db"
         );
 
-        let peerstate_new = Peerstate::from_addr(&ctx.ctx, addr)
-            .await
+        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr)
             .expect("failed to load peerstate from db");
 
         // clear to_save, as that is not persissted
         peerstate.to_save = None;
         assert_eq!(peerstate, peerstate_new);
         let peerstate_new2 =
-            Peerstate::from_fingerprint(&ctx.ctx, &ctx.ctx.sql, &pub_key.fingerprint().hex())
-                .await
+            Peerstate::from_fingerprint(&ctx.ctx, &ctx.ctx.sql, &pub_key.fingerprint())
                 .expect("failed to load peerstate from db");
         assert_eq!(peerstate, peerstate_new2);
     }
 
-    #[async_std::test]
-    async fn test_peerstate_double_create() {
-        let ctx = crate::test_utils::dummy_context().await;
+    #[test]
+    fn test_peerstate_double_create() {
+        let ctx = crate::test_utils::dummy_context();
         let addr = "hello@mail.com";
-        let pub_key = alice_keypair().public;
+        let pub_key = crate::key::Key::from(alice_keypair().public);
 
         let peerstate = Peerstate {
             context: &ctx.ctx,
@@ -544,7 +533,7 @@ mod tests {
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.fingerprint().hex()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: None,
             gossip_timestamp: 12,
             gossip_key_fingerprint: None,
@@ -555,21 +544,21 @@ mod tests {
         };
 
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
             "failed to save"
         );
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
             "double-call with create failed"
         );
     }
 
-    #[async_std::test]
-    async fn test_peerstate_with_empty_gossip_key_save_to_db() {
-        let ctx = crate::test_utils::dummy_context().await;
+    #[test]
+    fn test_peerstate_with_empty_gossip_key_save_to_db() {
+        let ctx = crate::test_utils::dummy_context();
         let addr = "hello@mail.com";
 
-        let pub_key = alice_keypair().public;
+        let pub_key = crate::key::Key::from(alice_keypair().public);
 
         let mut peerstate = Peerstate {
             context: &ctx.ctx,
@@ -578,7 +567,7 @@ mod tests {
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
             public_key: Some(pub_key.clone()),
-            public_key_fingerprint: Some(pub_key.fingerprint().hex()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
             gossip_key: None,
             gossip_timestamp: 12,
             gossip_key_fingerprint: None,
@@ -589,12 +578,11 @@ mod tests {
         };
 
         assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).await.is_ok(),
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
             "failed to save"
         );
 
-        let peerstate_new = Peerstate::from_addr(&ctx.ctx, addr)
-            .await
+        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr)
             .expect("failed to load peerstate from db");
 
         // clear to_save, as that is not persissted

src/pgp.rs

@@ -1,6 +1,7 @@
 //! OpenPGP helper module using [rPGP facilities](https://github.com/rpgp/rpgp)
 
 use std::collections::{BTreeMap, HashSet};
+use std::convert::TryInto;
 use std::io;
 use std::io::Cursor;
 
@@ -18,8 +19,8 @@ use rand::{thread_rng, CryptoRng, Rng};
 use crate::constants::KeyGenType;
 use crate::dc_tools::EmailAddress;
 use crate::error::{bail, ensure, format_err, Result};
-use crate::key::DcKey;
-use crate::keyring::Keyring;
+use crate::key::*;
+use crate::keyring::*;
 
 pub const HEADER_AUTOCRYPT: &str = "autocrypt-prefer-encrypt";
 pub const HEADER_SETUPCODE: &str = "passphrase-begin";
@@ -237,129 +238,124 @@ fn select_pk_for_encryption(key: &SignedPublicKey) -> Option<SignedPublicKeyOrSu
 
 /// Encrypts `plain` text using `public_keys_for_encryption`
 /// and signs it using `private_key_for_signing`.
-pub async fn pk_encrypt(
+pub fn pk_encrypt(
     plain: &[u8],
-    public_keys_for_encryption: Keyring<SignedPublicKey>,
-    private_key_for_signing: Option<SignedSecretKey>,
+    public_keys_for_encryption: &Keyring,
+    private_key_for_signing: Option<&Key>,
 ) -> Result<String> {
     let lit_msg = Message::new_literal_bytes("", plain);
+    let pkeys: Vec<SignedPublicKeyOrSubkey> = public_keys_for_encryption
+        .keys()
+        .iter()
+        .filter_map(|key| {
+            key.as_ref()
+                .try_into()
+                .ok()
+                .and_then(select_pk_for_encryption)
+        })
+        .collect();
+    let pkeys_refs: Vec<&SignedPublicKeyOrSubkey> = pkeys.iter().collect();
 
-    async_std::task::spawn_blocking(move || {
-        let pkeys: Vec<SignedPublicKeyOrSubkey> = public_keys_for_encryption
-            .keys()
-            .iter()
-            .filter_map(|key| select_pk_for_encryption(key))
-            .collect();
-        let pkeys_refs: Vec<&SignedPublicKeyOrSubkey> = pkeys.iter().collect();
+    let mut rng = thread_rng();
 
-        let mut rng = thread_rng();
+    // TODO: measure time
+    let encrypted_msg = if let Some(private_key) = private_key_for_signing {
+        let skey: &SignedSecretKey = private_key
+            .try_into()
+            .map_err(|_| format_err!("Invalid private key"))?;
 
-        // TODO: measure time
-        let encrypted_msg = if let Some(ref skey) = private_key_for_signing {
-            lit_msg
-                .sign(skey, || "".into(), Default::default())
-                .and_then(|msg| msg.compress(CompressionAlgorithm::ZLIB))
-                .and_then(|msg| msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys_refs))
-        } else {
-            lit_msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys_refs)
-        };
+        lit_msg
+            .sign(skey, || "".into(), Default::default())
+            .and_then(|msg| msg.compress(CompressionAlgorithm::ZLIB))
+            .and_then(|msg| msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys_refs))
+    } else {
+        lit_msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys_refs)
+    };
 
-        let msg = encrypted_msg?;
-        let encoded_msg = msg.to_armored_string(None)?;
+    let msg = encrypted_msg?;
+    let encoded_msg = msg.to_armored_string(None)?;
 
-        Ok(encoded_msg)
-    })
-    .await
+    Ok(encoded_msg)
 }
 
 #[allow(clippy::implicit_hasher)]
-pub async fn pk_decrypt(
-    ctext: Vec<u8>,
-    private_keys_for_decryption: Keyring<SignedSecretKey>,
-    public_keys_for_validation: Keyring<SignedPublicKey>,
+pub fn pk_decrypt(
+    ctext: &[u8],
+    private_keys_for_decryption: &Keyring,
+    public_keys_for_validation: &Keyring,
     ret_signature_fingerprints: Option<&mut HashSet<String>>,
 ) -> Result<Vec<u8>> {
-    let msgs = async_std::task::spawn_blocking(move || {
-        let cursor = Cursor::new(ctext);
-        let (msg, _) = Message::from_armor_single(cursor)?;
-
-        let skeys: Vec<&SignedSecretKey> = private_keys_for_decryption.keys().iter().collect();
-
-        let (decryptor, _) = msg.decrypt(|| "".into(), || "".into(), &skeys[..])?;
-        decryptor.collect::<pgp::errors::Result<Vec<_>>>()
-    })
-    .await?;
+    let (msg, _) = Message::from_armor_single(Cursor::new(ctext))?;
+    let skeys: Vec<&SignedSecretKey> = private_keys_for_decryption
+        .keys()
+        .iter()
+        .filter_map(|key| {
+            let k: &Key = &key;
+            k.try_into().ok()
+        })
+        .collect();
 
+    let (decryptor, _) = msg.decrypt(|| "".into(), || "".into(), &skeys[..])?;
+    let msgs = decryptor.collect::<pgp::errors::Result<Vec<_>>>()?;
     ensure!(!msgs.is_empty(), "No valid messages found");
 
-    let content = match msgs[0].get_content()? {
-        Some(content) => content,
-        None => bail!("Decrypted message is empty"),
-    };
+    let dec_msg = &msgs[0];
 
     if let Some(ret_signature_fingerprints) = ret_signature_fingerprints {
-        if !public_keys_for_validation.is_empty() {
-            let fingerprints = async_std::task::spawn_blocking(move || {
-                let dec_msg = &msgs[0];
+        if !public_keys_for_validation.keys().is_empty() {
+            let pkeys: Vec<&SignedPublicKey> = public_keys_for_validation
+                .keys()
+                .iter()
+                .filter_map(|key| {
+                    let k: &Key = &key;
+                    k.try_into().ok()
+                })
+                .collect();
 
-                let pkeys = public_keys_for_validation.keys();
-
-                let mut fingerprints = Vec::new();
-                for pkey in pkeys {
-                    if dec_msg.verify(&pkey.primary_key).is_ok() {
-                        let fp = DcKey::fingerprint(pkey).hex();
-                        fingerprints.push(fp);
-                    }
+            for pkey in &pkeys {
+                if dec_msg.verify(&pkey.primary_key).is_ok() {
+                    let fp = hex::encode_upper(pkey.fingerprint());
+                    ret_signature_fingerprints.insert(fp);
                 }
-                fingerprints
-            })
-            .await;
-
-            ret_signature_fingerprints.extend(fingerprints);
+            }
         }
     }
 
-    Ok(content)
+    match dec_msg.get_content()? {
+        Some(content) => Ok(content),
+        None => bail!("Decrypted message is empty"),
+    }
 }
 
 /// Symmetric encryption.
-pub async fn symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String> {
+pub fn symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String> {
+    let mut rng = thread_rng();
     let lit_msg = Message::new_literal_bytes("", plain);
-    let passphrase = passphrase.to_string();
 
-    async_std::task::spawn_blocking(move || {
-        let mut rng = thread_rng();
-        let s2k = StringToKey::new_default(&mut rng);
-        let msg =
-            lit_msg.encrypt_with_password(&mut rng, s2k, Default::default(), || passphrase)?;
+    let s2k = StringToKey::new_default(&mut rng);
+    let msg =
+        lit_msg.encrypt_with_password(&mut rng, s2k, Default::default(), || passphrase.into())?;
 
-        let encoded_msg = msg.to_armored_string(None)?;
+    let encoded_msg = msg.to_armored_string(None)?;
 
-        Ok(encoded_msg)
-    })
-    .await
+    Ok(encoded_msg)
 }
 
 /// Symmetric decryption.
-pub async fn symm_decrypt<T: std::io::Read + std::io::Seek>(
+pub fn symm_decrypt<T: std::io::Read + std::io::Seek>(
     passphrase: &str,
     ctext: T,
 ) -> Result<Vec<u8>> {
     let (enc_msg, _) = Message::from_armor_single(ctext)?;
+    let decryptor = enc_msg.decrypt_with_password(|| passphrase.into())?;
 
-    let passphrase = passphrase.to_string();
-    async_std::task::spawn_blocking(move || {
-        let decryptor = enc_msg.decrypt_with_password(|| passphrase)?;
+    let msgs = decryptor.collect::<pgp::errors::Result<Vec<_>>>()?;
+    ensure!(!msgs.is_empty(), "No valid messages found");
 
-        let msgs = decryptor.collect::<pgp::errors::Result<Vec<_>>>()?;
-        ensure!(!msgs.is_empty(), "No valid messages found");
-
-        match msgs[0].get_content()? {
-            Some(content) => Ok(content),
-            None => bail!("Decrypted message is empty"),
-        }
-    })
-    .await
+    match msgs[0].get_content()? {
+        Some(content) => Ok(content),
+        None => bail!("Decrypted message is empty"),
+    }
 }
 
 #[cfg(test)]
@@ -412,10 +408,10 @@ mod tests {
 
     /// [Key] objects to use in tests.
     struct TestKeys {
-        alice_secret: SignedSecretKey,
-        alice_public: SignedPublicKey,
-        bob_secret: SignedSecretKey,
-        bob_public: SignedPublicKey,
+        alice_secret: Key,
+        alice_public: Key,
+        bob_secret: Key,
+        bob_public: Key,
     }
 
     impl TestKeys {
@@ -423,10 +419,10 @@ mod tests {
             let alice = alice_keypair();
             let bob = bob_keypair();
             TestKeys {
-                alice_secret: alice.secret.clone(),
-                alice_public: alice.public.clone(),
-                bob_secret: bob.secret.clone(),
-                bob_public: bob.public.clone(),
+                alice_secret: Key::from(alice.secret.clone()),
+                alice_public: Key::from(alice.public.clone()),
+                bob_secret: Key::from(bob.secret.clone()),
+                bob_public: Key::from(bob.public.clone()),
             }
         }
     }
@@ -440,18 +436,18 @@ mod tests {
 
         /// A cyphertext encrypted to Alice & Bob, signed by Alice.
         static ref CTEXT_SIGNED: String = {
-            let mut keyring = Keyring::new();
-            keyring.add(KEYS.alice_public.clone());
-            keyring.add(KEYS.bob_public.clone());
-            smol::block_on(pk_encrypt(CLEARTEXT, keyring, Some(KEYS.alice_secret.clone()))).unwrap()
+            let mut keyring = Keyring::default();
+            keyring.add_owned(KEYS.alice_public.clone());
+            keyring.add_ref(&KEYS.bob_public);
+            pk_encrypt(CLEARTEXT, &keyring, Some(&KEYS.alice_secret)).unwrap()
         };
 
         /// A cyphertext encrypted to Alice & Bob, not signed.
         static ref CTEXT_UNSIGNED: String = {
-            let mut keyring = Keyring::new();
-            keyring.add(KEYS.alice_public.clone());
-            keyring.add(KEYS.bob_public.clone());
-            smol::block_on(pk_encrypt(CLEARTEXT, keyring, None)).unwrap()
+            let mut keyring = Keyring::default();
+            keyring.add_owned(KEYS.alice_public.clone());
+            keyring.add_ref(&KEYS.bob_public);
+            pk_encrypt(CLEARTEXT, &keyring, None).unwrap()
         };
     }
 
@@ -467,115 +463,110 @@ mod tests {
         assert!(CTEXT_UNSIGNED.starts_with("-----BEGIN PGP MESSAGE-----"));
     }
 
-    #[async_std::test]
-    async fn test_decrypt_singed() {
+    #[test]
+    fn test_decrypt_singed() {
         // Check decrypting as Alice
-        let mut decrypt_keyring: Keyring<SignedSecretKey> = Keyring::new();
-        decrypt_keyring.add(KEYS.alice_secret.clone());
-        let mut sig_check_keyring: Keyring<SignedPublicKey> = Keyring::new();
-        sig_check_keyring.add(KEYS.alice_public.clone());
+        let mut decrypt_keyring = Keyring::default();
+        decrypt_keyring.add_ref(&KEYS.alice_secret);
+        let mut sig_check_keyring = Keyring::default();
+        sig_check_keyring.add_ref(&KEYS.alice_public);
         let mut valid_signatures: HashSet<String> = Default::default();
         let plain = pk_decrypt(
-            CTEXT_SIGNED.as_bytes().to_vec(),
-            decrypt_keyring,
-            sig_check_keyring,
+            CTEXT_SIGNED.as_bytes(),
+            &decrypt_keyring,
+            &sig_check_keyring,
             Some(&mut valid_signatures),
         )
-        .await
         .map_err(|err| println!("{:?}", err))
         .unwrap();
         assert_eq!(plain, CLEARTEXT);
         assert_eq!(valid_signatures.len(), 1);
 
         // Check decrypting as Bob
-        let mut decrypt_keyring = Keyring::new();
-        decrypt_keyring.add(KEYS.bob_secret.clone());
-        let mut sig_check_keyring = Keyring::new();
-        sig_check_keyring.add(KEYS.alice_public.clone());
+        let mut decrypt_keyring = Keyring::default();
+        decrypt_keyring.add_ref(&KEYS.bob_secret);
+        let mut sig_check_keyring = Keyring::default();
+        sig_check_keyring.add_ref(&KEYS.alice_public);
         let mut valid_signatures: HashSet<String> = Default::default();
         let plain = pk_decrypt(
-            CTEXT_SIGNED.as_bytes().to_vec(),
-            decrypt_keyring,
-            sig_check_keyring,
+            CTEXT_SIGNED.as_bytes(),
+            &decrypt_keyring,
+            &sig_check_keyring,
             Some(&mut valid_signatures),
         )
-        .await
         .map_err(|err| println!("{:?}", err))
         .unwrap();
         assert_eq!(plain, CLEARTEXT);
         assert_eq!(valid_signatures.len(), 1);
     }
 
-    #[async_std::test]
-    async fn test_decrypt_no_sig_check() {
-        let mut keyring = Keyring::new();
-        keyring.add(KEYS.alice_secret.clone());
-        let empty_keyring = Keyring::new();
+    #[test]
+    fn test_decrypt_no_sig_check() {
+        let mut keyring = Keyring::default();
+        keyring.add_ref(&KEYS.alice_secret);
+        let empty_keyring = Keyring::default();
         let mut valid_signatures: HashSet<String> = Default::default();
         let plain = pk_decrypt(
-            CTEXT_SIGNED.as_bytes().to_vec(),
-            keyring,
-            empty_keyring,
+            CTEXT_SIGNED.as_bytes(),
+            &keyring,
+            &empty_keyring,
             Some(&mut valid_signatures),
         )
-        .await
         .unwrap();
         assert_eq!(plain, CLEARTEXT);
         assert_eq!(valid_signatures.len(), 0);
     }
 
-    #[async_std::test]
-    async fn test_decrypt_signed_no_key() {
+    #[test]
+    fn test_decrypt_signed_no_key() {
         // The validation does not have the public key of the signer.
-        let mut decrypt_keyring = Keyring::new();
-        decrypt_keyring.add(KEYS.bob_secret.clone());
-        let mut sig_check_keyring = Keyring::new();
-        sig_check_keyring.add(KEYS.bob_public.clone());
+        let mut decrypt_keyring = Keyring::default();
+        decrypt_keyring.add_ref(&KEYS.bob_secret);
+        let mut sig_check_keyring = Keyring::default();
+        sig_check_keyring.add_ref(&KEYS.bob_public);
         let mut valid_signatures: HashSet<String> = Default::default();
         let plain = pk_decrypt(
-            CTEXT_SIGNED.as_bytes().to_vec(),
-            decrypt_keyring,
-            sig_check_keyring,
+            CTEXT_SIGNED.as_bytes(),
+            &decrypt_keyring,
+            &sig_check_keyring,
             Some(&mut valid_signatures),
         )
-        .await
         .unwrap();
         assert_eq!(plain, CLEARTEXT);
         assert_eq!(valid_signatures.len(), 0);
     }
 
-    #[async_std::test]
-    async fn test_decrypt_unsigned() {
-        let mut decrypt_keyring = Keyring::new();
-        decrypt_keyring.add(KEYS.bob_secret.clone());
-        let sig_check_keyring = Keyring::new();
+    #[test]
+    fn test_decrypt_unsigned() {
+        let mut decrypt_keyring = Keyring::default();
+        decrypt_keyring.add_ref(&KEYS.bob_secret);
+        let sig_check_keyring = Keyring::default();
+        decrypt_keyring.add_ref(&KEYS.alice_public);
         let mut valid_signatures: HashSet<String> = Default::default();
         let plain = pk_decrypt(
-            CTEXT_UNSIGNED.as_bytes().to_vec(),
-            decrypt_keyring,
-            sig_check_keyring,
+            CTEXT_UNSIGNED.as_bytes(),
+            &decrypt_keyring,
+            &sig_check_keyring,
             Some(&mut valid_signatures),
         )
-        .await
         .unwrap();
         assert_eq!(plain, CLEARTEXT);
         assert_eq!(valid_signatures.len(), 0);
     }
 
-    #[async_std::test]
-    async fn test_decrypt_signed_no_sigret() {
+    #[test]
+    fn test_decrypt_signed_no_sigret() {
         // Check decrypting signed cyphertext without providing the HashSet for signatures.
-        let mut decrypt_keyring = Keyring::new();
-        decrypt_keyring.add(KEYS.bob_secret.clone());
-        let mut sig_check_keyring = Keyring::new();
-        sig_check_keyring.add(KEYS.alice_public.clone());
+        let mut decrypt_keyring = Keyring::default();
+        decrypt_keyring.add_ref(&KEYS.bob_secret);
+        let mut sig_check_keyring = Keyring::default();
+        sig_check_keyring.add_ref(&KEYS.alice_public);
         let plain = pk_decrypt(
-            CTEXT_SIGNED.as_bytes().to_vec(),
-            decrypt_keyring,
-            sig_check_keyring,
+            CTEXT_SIGNED.as_bytes(),
+            &decrypt_keyring,
+            &sig_check_keyring,
             None,
         )
-        .await
         .unwrap();
         assert_eq!(plain, CLEARTEXT);
     }

src/qr.rs

@@ -2,6 +2,7 @@
 
 use lazy_static::lazy_static;
 use percent_encoding::percent_decode_str;
+use reqwest::Url;
 use serde::Deserialize;
 
 use crate::chat;
@@ -43,23 +44,23 @@ fn starts_with_ignore_case(string: &str, pattern: &str) -> bool {
 /// Check a scanned QR code.
 /// The function should be called after a QR code is scanned.
 /// The function takes the raw text scanned and checks what can be done with it.
-pub async fn check_qr(context: &Context, qr: impl AsRef<str>) -> Lot {
+pub fn check_qr(context: &Context, qr: impl AsRef<str>) -> Lot {
     let qr = qr.as_ref();
 
     info!(context, "Scanned QR code: {}", qr);
 
     if starts_with_ignore_case(qr, OPENPGP4FPR_SCHEME) {
-        decode_openpgp(context, qr).await
+        decode_openpgp(context, qr)
     } else if starts_with_ignore_case(qr, DCACCOUNT_SCHEME) {
         decode_account(context, qr)
     } else if qr.starts_with(MAILTO_SCHEME) {
-        decode_mailto(context, qr).await
+        decode_mailto(context, qr)
     } else if qr.starts_with(SMTP_SCHEME) {
-        decode_smtp(context, qr).await
+        decode_smtp(context, qr)
     } else if qr.starts_with(MATMSG_SCHEME) {
-        decode_matmsg(context, qr).await
+        decode_matmsg(context, qr)
     } else if qr.starts_with(VCARD_SCHEME) {
-        decode_vcard(context, qr).await
+        decode_vcard(context, qr)
     } else if qr.starts_with(HTTP_SCHEME) || qr.starts_with(HTTPS_SCHEME) {
         Lot::from_url(qr)
     } else {
@@ -69,7 +70,7 @@ pub async fn check_qr(context: &Context, qr: impl AsRef<str>) -> Lot {
 
 /// scheme: `OPENPGP4FPR:FINGERPRINT#a=ADDR&n=NAME&i=INVITENUMBER&s=AUTH`
 ///     or: `OPENPGP4FPR:FINGERPRINT#a=ADDR&g=GROUPNAME&x=GROUPID&i=INVITENUMBER&s=AUTH`
-async fn decode_openpgp(context: &Context, qr: &str) -> Lot {
+fn decode_openpgp(context: &Context, qr: &str) -> Lot {
     let payload = &qr[OPENPGP4FPR_SCHEME.len()..];
 
     let (fingerprint, fragment) = match payload.find('#').map(|offset| {
@@ -135,10 +136,15 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Lot {
         return format_err!("Bad fingerprint length in QR code").into();
     }
 
+    println!(
+        "{:?} {:?} {:?} {:?} {:?} {:?} {:?}",
+        addr, name, invitenumber, auth, grpid, grpname, fingerprint
+    );
+
     let mut lot = Lot::new();
 
     // retrieve known state for this fingerprint
-    let peerstate = Peerstate::from_fingerprint(context, &context.sql, &fingerprint).await;
+    let peerstate = Peerstate::from_fingerprint(context, &context.sql, &fingerprint);
 
     if invitenumber.is_none() || auth.is_none() {
         if let Some(peerstate) = peerstate {
@@ -150,15 +156,13 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Lot {
                 peerstate.addr.clone(),
                 Origin::UnhandledQrScan,
             )
-            .await
             .map(|(id, _)| id)
             .unwrap_or_default();
 
             let (id, _) = chat::create_or_lookup_by_contact_id(context, lot.id, Blocked::Deaddrop)
-                .await
                 .unwrap_or_default();
 
-            chat::add_info_msg(context, id, format!("{} verified.", peerstate.addr)).await;
+            chat::add_info_msg(context, id, format!("{} verified.", peerstate.addr));
         } else {
             lot.state = LotState::QrFprWithoutAddr;
             lot.text1 = Some(dc_format_fingerprint(&fingerprint));
@@ -172,7 +176,6 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Lot {
             lot.state = LotState::QrAskVerifyContact;
         }
         lot.id = Contact::add_or_lookup(context, &name, &addr, Origin::UnhandledQrScan)
-            .await
             .map(|(id, _)| id)
             .unwrap_or_default();
 
@@ -192,7 +195,7 @@ fn decode_account(_context: &Context, qr: &str) -> Lot {
 
     let mut lot = Lot::new();
 
-    if let Ok(url) = url::Url::parse(payload) {
+    if let Ok(url) = Url::parse(payload) {
         if url.scheme() == "https" {
             lot.state = LotState::QrAccount;
             lot.text1 = url.host_str().map(|x| x.to_string());
@@ -217,22 +220,31 @@ struct CreateAccountResponse {
 /// take a qr of the type DC_QR_ACCOUNT, parse it's parameters,
 /// download additional information from the contained url and set the parameters.
 /// on success, a configure::configure() should be able to log in to the account
-pub async fn set_config_from_qr(context: &Context, qr: &str) -> Result<(), Error> {
+pub fn set_config_from_qr(context: &Context, qr: &str) -> Result<(), Error> {
     let url_str = &qr[DCACCOUNT_SCHEME.len()..];
 
-    let response: Result<CreateAccountResponse, surf::Error> =
-        surf::post(url_str).recv_json().await;
+    let response = reqwest::blocking::Client::new().post(url_str).send();
     if response.is_err() {
         bail!("Cannot create account, request to {} failed", url_str);
     }
-    let parsed = response.unwrap();
+    let response = response.unwrap();
+    if !response.status().is_success() {
+        bail!("Request to {} unsuccessful: {:?}", url_str, response);
+    }
 
-    context
-        .set_config(Config::Addr, Some(&parsed.email))
-        .await?;
-    context
-        .set_config(Config::MailPw, Some(&parsed.password))
-        .await?;
+    let parsed: reqwest::Result<CreateAccountResponse> = response.json();
+    if parsed.is_err() {
+        bail!(
+            "Failed to parse JSON response from {}: error: {:?}",
+            url_str,
+            parsed
+        );
+    }
+    println!("response: {:?}", &parsed);
+    let parsed = parsed.unwrap();
+
+    context.set_config(Config::Addr, Some(&parsed.email))?;
+    context.set_config(Config::MailPw, Some(&parsed.password))?;
 
     Ok(())
 }
@@ -240,7 +252,7 @@ pub async fn set_config_from_qr(context: &Context, qr: &str) -> Result<(), Error
 /// Extract address for the mailto scheme.
 ///
 /// Scheme: `mailto:addr...?subject=...&body=..`
-async fn decode_mailto(context: &Context, qr: &str) -> Lot {
+fn decode_mailto(context: &Context, qr: &str) -> Lot {
     let payload = &qr[MAILTO_SCHEME.len()..];
 
     let addr = if let Some(query_index) = payload.find('?') {
@@ -255,13 +267,13 @@ async fn decode_mailto(context: &Context, qr: &str) -> Lot {
     };
 
     let name = "".to_string();
-    Lot::from_address(context, name, addr).await
+    Lot::from_address(context, name, addr)
 }
 
 /// Extract address for the smtp scheme.
 ///
 /// Scheme: `SMTP:addr...:subject...:body...`
-async fn decode_smtp(context: &Context, qr: &str) -> Lot {
+fn decode_smtp(context: &Context, qr: &str) -> Lot {
     let payload = &qr[SMTP_SCHEME.len()..];
 
     let addr = if let Some(query_index) = payload.find(':') {
@@ -275,7 +287,7 @@ async fn decode_smtp(context: &Context, qr: &str) -> Lot {
         Err(err) => return err.into(),
     };
     let name = "".to_string();
-    Lot::from_address(context, name, addr).await
+    Lot::from_address(context, name, addr)
 }
 
 /// Extract address for the matmsg scheme.
@@ -283,7 +295,7 @@ async fn decode_smtp(context: &Context, qr: &str) -> Lot {
 /// Scheme: `MATMSG:TO:addr...;SUB:subject...;BODY:body...;`
 ///
 /// There may or may not be linebreaks after the fields.
-async fn decode_matmsg(context: &Context, qr: &str) -> Lot {
+fn decode_matmsg(context: &Context, qr: &str) -> Lot {
     // Does not work when the text `TO:` is used in subject/body _and_ TO: is not the first field.
     // we ignore this case.
     let addr = if let Some(to_index) = qr.find("TO:") {
@@ -303,7 +315,7 @@ async fn decode_matmsg(context: &Context, qr: &str) -> Lot {
     };
 
     let name = "".to_string();
-    Lot::from_address(context, name, addr).await
+    Lot::from_address(context, name, addr)
 }
 
 lazy_static! {
@@ -316,7 +328,7 @@ lazy_static! {
 /// Extract address for the matmsg scheme.
 ///
 /// Scheme: `VCARD:BEGIN\nN:last name;first name;...;\nEMAIL;<type>:addr...;
-async fn decode_vcard(context: &Context, qr: &str) -> Lot {
+fn decode_vcard(context: &Context, qr: &str) -> Lot {
     let name = VCARD_NAME_RE
         .captures(qr)
         .map(|caps| {
@@ -336,7 +348,7 @@ async fn decode_vcard(context: &Context, qr: &str) -> Lot {
         return format_err!("Bad e-mail address").into();
     };
 
-    Lot::from_address(context, name, addr).await
+    Lot::from_address(context, name, addr)
 }
 
 impl Lot {
@@ -356,10 +368,10 @@ impl Lot {
         l
     }
 
-    pub async fn from_address(context: &Context, name: String, addr: String) -> Self {
+    pub fn from_address(context: &Context, name: String, addr: String) -> Self {
         let mut l = Lot::new();
         l.state = LotState::QrAddr;
-        l.id = match Contact::add_or_lookup(context, name, addr, Origin::UnhandledQrScan).await {
+        l.id = match Contact::add_or_lookup(context, name, addr, Origin::UnhandledQrScan) {
             Ok((id, _)) => id,
             Err(err) => return err.into(),
         };
@@ -385,11 +397,11 @@ mod tests {
 
     use crate::test_utils::dummy_context;
 
-    #[async_std::test]
-    async fn test_decode_http() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_http() {
+        let ctx = dummy_context();
 
-        let res = check_qr(&ctx.ctx, "http://www.hello.com").await;
+        let res = check_qr(&ctx.ctx, "http://www.hello.com");
 
         assert_eq!(res.get_state(), LotState::QrUrl);
         assert_eq!(res.get_id(), 0);
@@ -397,11 +409,11 @@ mod tests {
         assert!(res.get_text2().is_none());
     }
 
-    #[async_std::test]
-    async fn test_decode_https() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_https() {
+        let ctx = dummy_context();
 
-        let res = check_qr(&ctx.ctx, "https://www.hello.com").await;
+        let res = check_qr(&ctx.ctx, "https://www.hello.com");
 
         assert_eq!(res.get_state(), LotState::QrUrl);
         assert_eq!(res.get_id(), 0);
@@ -409,11 +421,11 @@ mod tests {
         assert!(res.get_text2().is_none());
     }
 
-    #[async_std::test]
-    async fn test_decode_text() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_text() {
+        let ctx = dummy_context();
 
-        let res = check_qr(&ctx.ctx, "I am so cool").await;
+        let res = check_qr(&ctx.ctx, "I am so cool");
 
         assert_eq!(res.get_state(), LotState::QrText);
         assert_eq!(res.get_id(), 0);
@@ -421,90 +433,88 @@ mod tests {
         assert!(res.get_text2().is_none());
     }
 
-    #[async_std::test]
-    async fn test_decode_vcard() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_vcard() {
+        let ctx = dummy_context();
 
         let res = check_qr(
             &ctx.ctx,
             "BEGIN:VCARD\nVERSION:3.0\nN:Last;First\nEMAIL;TYPE=INTERNET:stress@test.local\nEND:VCARD"
-        ).await;
+        );
 
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAddr);
         assert_ne!(res.get_id(), 0);
 
-        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).await.unwrap();
+        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).unwrap();
         assert_eq!(contact.get_addr(), "stress@test.local");
         assert_eq!(contact.get_name(), "First Last");
     }
 
-    #[async_std::test]
-    async fn test_decode_matmsg() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_matmsg() {
+        let ctx = dummy_context();
 
         let res = check_qr(
             &ctx.ctx,
             "MATMSG:TO:\n\nstress@test.local ; \n\nSUB:\n\nSubject here\n\nBODY:\n\nhelloworld\n;;",
-        )
-        .await;
+        );
 
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAddr);
         assert_ne!(res.get_id(), 0);
 
-        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).await.unwrap();
+        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).unwrap();
         assert_eq!(contact.get_addr(), "stress@test.local");
     }
 
-    #[async_std::test]
-    async fn test_decode_mailto() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_mailto() {
+        let ctx = dummy_context();
 
         let res = check_qr(
             &ctx.ctx,
             "mailto:stress@test.local?subject=hello&body=world",
-        )
-        .await;
+        );
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAddr);
         assert_ne!(res.get_id(), 0);
-        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).await.unwrap();
+        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).unwrap();
         assert_eq!(contact.get_addr(), "stress@test.local");
 
-        let res = check_qr(&ctx.ctx, "mailto:no-questionmark@example.org").await;
+        let res = check_qr(&ctx.ctx, "mailto:no-questionmark@example.org");
         assert_eq!(res.get_state(), LotState::QrAddr);
         assert_ne!(res.get_id(), 0);
-        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).await.unwrap();
+        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).unwrap();
         assert_eq!(contact.get_addr(), "no-questionmark@example.org");
 
-        let res = check_qr(&ctx.ctx, "mailto:no-addr").await;
+        let res = check_qr(&ctx.ctx, "mailto:no-addr");
         assert_eq!(res.get_state(), LotState::QrError);
         assert!(res.get_text1().is_some());
     }
 
-    #[async_std::test]
-    async fn test_decode_smtp() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_smtp() {
+        let ctx = dummy_context();
 
-        let res = check_qr(&ctx.ctx, "SMTP:stress@test.local:subjecthello:bodyworld").await;
+        let res = check_qr(&ctx.ctx, "SMTP:stress@test.local:subjecthello:bodyworld");
 
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAddr);
         assert_ne!(res.get_id(), 0);
 
-        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).await.unwrap();
+        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).unwrap();
         assert_eq!(contact.get_addr(), "stress@test.local");
     }
 
-    #[async_std::test]
-    async fn test_decode_openpgp_group() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_openpgp_group() {
+        let ctx = dummy_context();
 
         let res = check_qr(
             &ctx.ctx,
             "OPENPGP4FPR:79252762C34C5096AF57958F4FC3D21A81B0F0A7#a=cli%40deltachat.de&g=test%20%3F+test%20%21&x=h-0oKQf2CDK&i=9JEXlxAqGM0&s=0V7LzL9cxRL"
-        ).await;
+        );
 
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAskVerifyGroup);
@@ -515,25 +525,25 @@ mod tests {
         let res = check_qr(
             &ctx.ctx,
             "openpgp4fpr:79252762C34C5096AF57958F4FC3D21A81B0F0A7#a=cli%40deltachat.de&g=test%20%3F+test%20%21&x=h-0oKQf2CDK&i=9JEXlxAqGM0&s=0V7LzL9cxRL"
-        ).await;
+        );
 
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAskVerifyGroup);
         assert_ne!(res.get_id(), 0);
         assert_eq!(res.get_text1().unwrap(), "test ? test !");
 
-        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).await.unwrap();
+        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).unwrap();
         assert_eq!(contact.get_addr(), "cli@deltachat.de");
     }
 
-    #[async_std::test]
-    async fn test_decode_openpgp_secure_join() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_openpgp_secure_join() {
+        let ctx = dummy_context();
 
         let res = check_qr(
             &ctx.ctx,
             "OPENPGP4FPR:79252762C34C5096AF57958F4FC3D21A81B0F0A7#a=cli%40deltachat.de&n=J%C3%B6rn%20P.+P.&i=TbnwJ6lSvD5&s=0ejvbdFSQxB"
-        ).await;
+        );
 
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAskVerifyContact);
@@ -543,26 +553,25 @@ mod tests {
         let res = check_qr(
             &ctx.ctx,
             "openpgp4fpr:79252762C34C5096AF57958F4FC3D21A81B0F0A7#a=cli%40deltachat.de&n=J%C3%B6rn%20P.+P.&i=TbnwJ6lSvD5&s=0ejvbdFSQxB"
-        ).await;
+        );
 
         println!("{:?}", res);
         assert_eq!(res.get_state(), LotState::QrAskVerifyContact);
         assert_ne!(res.get_id(), 0);
 
-        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).await.unwrap();
+        let contact = Contact::get_by_id(&ctx.ctx, res.get_id()).unwrap();
         assert_eq!(contact.get_addr(), "cli@deltachat.de");
         assert_eq!(contact.get_name(), "Jörn P. P.");
     }
 
-    #[async_std::test]
-    async fn test_decode_openpgp_without_addr() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_openpgp_without_addr() {
+        let ctx = dummy_context();
 
         let res = check_qr(
             &ctx.ctx,
             "OPENPGP4FPR:1234567890123456789012345678901234567890",
-        )
-        .await;
+        );
         assert_eq!(res.get_state(), LotState::QrFprWithoutAddr);
         assert_eq!(
             res.get_text1().unwrap(),
@@ -575,8 +584,7 @@ mod tests {
         let res = check_qr(
             &ctx.ctx,
             "openpgp4fpr:1234567890123456789012345678901234567890",
-        )
-        .await;
+        );
         assert_eq!(res.get_state(), LotState::QrFprWithoutAddr);
         assert_eq!(
             res.get_text1().unwrap(),
@@ -584,20 +592,19 @@ mod tests {
         );
         assert_eq!(res.get_id(), 0);
 
-        let res = check_qr(&ctx.ctx, "OPENPGP4FPR:12345678901234567890").await;
+        let res = check_qr(&ctx.ctx, "OPENPGP4FPR:12345678901234567890");
         assert_eq!(res.get_state(), LotState::QrError);
         assert_eq!(res.get_id(), 0);
     }
 
-    #[async_std::test]
-    async fn test_decode_account() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_account() {
+        let ctx = dummy_context();
 
         let res = check_qr(
             &ctx.ctx,
             "DCACCOUNT:https://example.org/new_email?t=1w_7wDjgjelxeX884x96v3",
-        )
-        .await;
+        );
         assert_eq!(res.get_state(), LotState::QrAccount);
         assert_eq!(res.get_text1().unwrap(), "example.org");
 
@@ -605,20 +612,19 @@ mod tests {
         let res = check_qr(
             &ctx.ctx,
             "dcaccount:https://example.org/new_email?t=1w_7wDjgjelxeX884x96v3",
-        )
-        .await;
+        );
         assert_eq!(res.get_state(), LotState::QrAccount);
         assert_eq!(res.get_text1().unwrap(), "example.org");
     }
 
-    #[async_std::test]
-    async fn test_decode_account_bad_scheme() {
-        let ctx = dummy_context().await;
+    #[test]
+    fn test_decode_account_bad_scheme() {
+        let ctx = dummy_context();
+
         let res = check_qr(
             &ctx.ctx,
             "DCACCOUNT:http://example.org/new_email?t=1w_7wDjgjelxeX884x96v3",
-        )
-        .await;
+        );
         assert_eq!(res.get_state(), LotState::QrError);
         assert!(res.get_text1().is_some());
 
@@ -626,8 +632,7 @@ mod tests {
         let res = check_qr(
             &ctx.ctx,
             "dcaccount:http://example.org/new_email?t=1w_7wDjgjelxeX884x96v3",
-        )
-        .await;
+        );
         assert_eq!(res.get_state(), LotState::QrError);
         assert!(res.get_text1().is_some());
     }

src/scheduler.rs

@@ -1,592 +0,0 @@
-use async_std::prelude::*;
-use async_std::sync::{channel, Receiver, Sender};
-use async_std::task;
-
-use crate::context::Context;
-use crate::imap::Imap;
-use crate::job::{self, Thread};
-use crate::smtp::Smtp;
-
-pub(crate) struct StopToken;
-
-/// Job and connection scheduler.
-#[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
-pub(crate) enum Scheduler {
-    Stopped,
-    Running {
-        inbox: ImapConnectionState,
-        inbox_handle: Option<task::JoinHandle<()>>,
-        mvbox: ImapConnectionState,
-        mvbox_handle: Option<task::JoinHandle<()>>,
-        sentbox: ImapConnectionState,
-        sentbox_handle: Option<task::JoinHandle<()>>,
-        smtp: SmtpConnectionState,
-        smtp_handle: Option<task::JoinHandle<()>>,
-    },
-}
-
-impl Context {
-    /// Indicate that the network likely has come back.
-    pub async fn maybe_network(&self) {
-        self.scheduler.read().await.maybe_network().await;
-    }
-
-    pub(crate) async fn interrupt_inbox(&self, probe_network: bool) {
-        self.scheduler
-            .read()
-            .await
-            .interrupt_inbox(probe_network)
-            .await;
-    }
-
-    pub(crate) async fn interrupt_sentbox(&self, probe_network: bool) {
-        self.scheduler
-            .read()
-            .await
-            .interrupt_sentbox(probe_network)
-            .await;
-    }
-
-    pub(crate) async fn interrupt_mvbox(&self, probe_network: bool) {
-        self.scheduler
-            .read()
-            .await
-            .interrupt_mvbox(probe_network)
-            .await;
-    }
-
-    pub(crate) async fn interrupt_smtp(&self, probe_network: bool) {
-        self.scheduler
-            .read()
-            .await
-            .interrupt_smtp(probe_network)
-            .await;
-    }
-}
-
-async fn inbox_loop(ctx: Context, started: Sender<()>, inbox_handlers: ImapConnectionHandlers) {
-    use futures::future::FutureExt;
-
-    info!(ctx, "starting inbox loop");
-    let ImapConnectionHandlers {
-        mut connection,
-        stop_receiver,
-        shutdown_sender,
-    } = inbox_handlers;
-
-    let ctx1 = ctx.clone();
-    let fut = async move {
-        started.send(()).await;
-        let ctx = ctx1;
-        if let Err(err) = connection.connect_configured(&ctx).await {
-            error!(ctx, "{}", err);
-            return;
-        }
-
-        // track number of continously executed jobs
-        let mut jobs_loaded = 0;
-        let mut probe_network = false;
-        loop {
-            match job::load_next(&ctx, Thread::Imap, probe_network).await {
-                Some(job) if jobs_loaded <= 20 => {
-                    jobs_loaded += 1;
-                    job::perform_job(&ctx, job::Connection::Inbox(&mut connection), job).await;
-                    probe_network = false;
-                }
-                Some(job) => {
-                    // Let the fetch run, but return back to the job afterwards.
-                    info!(ctx, "postponing imap-job {} to run fetch...", job);
-                    jobs_loaded = 0;
-                    fetch(&ctx, &mut connection).await;
-                }
-                None => {
-                    jobs_loaded = 0;
-                    probe_network = fetch_idle(&ctx, &mut connection).await;
-                }
-            }
-        }
-    };
-
-    stop_receiver
-        .recv()
-        .map(|_| {
-            info!(ctx, "shutting down inbox loop");
-        })
-        .race(fut)
-        .await;
-    shutdown_sender.send(()).await;
-}
-
-async fn fetch(ctx: &Context, connection: &mut Imap) {
-    match get_watch_folder(&ctx, "configured_inbox_folder").await {
-        Some(watch_folder) => {
-            // fetch
-            connection
-                .fetch(&ctx, &watch_folder)
-                .await
-                .unwrap_or_else(|err| {
-                    error!(ctx, "{}", err);
-                });
-        }
-        None => {
-            warn!(ctx, "Can not fetch inbox folder, not set");
-            connection.fake_idle(&ctx, None).await;
-        }
-    }
-}
-
-async fn fetch_idle(ctx: &Context, connection: &mut Imap) -> bool {
-    match get_watch_folder(&ctx, "configured_inbox_folder").await {
-        Some(watch_folder) => {
-            // fetch
-            connection
-                .fetch(&ctx, &watch_folder)
-                .await
-                .unwrap_or_else(|err| {
-                    error!(ctx, "{}", err);
-                });
-
-            // idle
-            if connection.can_idle() {
-                connection
-                    .idle(&ctx, Some(watch_folder))
-                    .await
-                    .unwrap_or_else(|err| {
-                        error!(ctx, "{}", err);
-                        false
-                    })
-            } else {
-                connection.fake_idle(&ctx, Some(watch_folder)).await
-            }
-        }
-        None => {
-            warn!(ctx, "Can not watch inbox folder, not set");
-            connection.fake_idle(&ctx, None).await
-        }
-    }
-}
-
-async fn simple_imap_loop(
-    ctx: Context,
-    started: Sender<()>,
-    inbox_handlers: ImapConnectionHandlers,
-    folder: impl AsRef<str>,
-) {
-    use futures::future::FutureExt;
-
-    info!(ctx, "starting simple loop for {}", folder.as_ref());
-    let ImapConnectionHandlers {
-        mut connection,
-        stop_receiver,
-        shutdown_sender,
-    } = inbox_handlers;
-
-    let ctx1 = ctx.clone();
-
-    let fut = async move {
-        started.send(()).await;
-        let ctx = ctx1;
-        if let Err(err) = connection.connect_configured(&ctx).await {
-            error!(ctx, "{}", err);
-            return;
-        }
-
-        loop {
-            match get_watch_folder(&ctx, folder.as_ref()).await {
-                Some(watch_folder) => {
-                    // fetch
-                    connection
-                        .fetch(&ctx, &watch_folder)
-                        .await
-                        .unwrap_or_else(|err| {
-                            error!(ctx, "{}", err);
-                        });
-
-                    // idle
-                    if connection.can_idle() {
-                        connection
-                            .idle(&ctx, Some(watch_folder))
-                            .await
-                            .unwrap_or_else(|err| {
-                                error!(ctx, "{}", err);
-                                false
-                            });
-                    } else {
-                        connection.fake_idle(&ctx, Some(watch_folder)).await;
-                    }
-                }
-                None => {
-                    warn!(
-                        &ctx,
-                        "No watch folder found for {}, skipping",
-                        folder.as_ref()
-                    );
-                    connection.fake_idle(&ctx, None).await;
-                }
-            }
-        }
-    };
-
-    stop_receiver
-        .recv()
-        .map(|_| {
-            info!(ctx, "shutting down simple loop");
-        })
-        .race(fut)
-        .await;
-    shutdown_sender.send(()).await;
-}
-
-async fn smtp_loop(ctx: Context, started: Sender<()>, smtp_handlers: SmtpConnectionHandlers) {
-    use futures::future::FutureExt;
-
-    info!(ctx, "starting smtp loop");
-    let SmtpConnectionHandlers {
-        mut connection,
-        stop_receiver,
-        shutdown_sender,
-        idle_interrupt_receiver,
-    } = smtp_handlers;
-
-    let ctx1 = ctx.clone();
-    let fut = async move {
-        started.send(()).await;
-        let ctx = ctx1;
-
-        let mut probe_network = false;
-        loop {
-            match job::load_next(&ctx, Thread::Smtp, probe_network).await {
-                Some(job) => {
-                    info!(ctx, "executing smtp job");
-                    job::perform_job(&ctx, job::Connection::Smtp(&mut connection), job).await;
-                    probe_network = false;
-                }
-                None => {
-                    // Fake Idle
-                    info!(ctx, "smtp fake idle - started");
-                    probe_network = idle_interrupt_receiver.recv().await.unwrap_or_default();
-                    info!(ctx, "smtp fake idle - interrupted")
-                }
-            }
-        }
-    };
-
-    stop_receiver
-        .recv()
-        .map(|_| {
-            info!(ctx, "shutting down smtp loop");
-        })
-        .race(fut)
-        .await;
-    shutdown_sender.send(()).await;
-}
-
-impl Scheduler {
-    /// Start the scheduler, panics if it is already running.
-    pub async fn start(&mut self, ctx: Context) {
-        let (mvbox, mvbox_handlers) = ImapConnectionState::new();
-        let (sentbox, sentbox_handlers) = ImapConnectionState::new();
-        let (smtp, smtp_handlers) = SmtpConnectionState::new();
-        let (inbox, inbox_handlers) = ImapConnectionState::new();
-
-        *self = Scheduler::Running {
-            inbox,
-            mvbox,
-            sentbox,
-            smtp,
-            inbox_handle: None,
-            mvbox_handle: None,
-            sentbox_handle: None,
-            smtp_handle: None,
-        };
-
-        let (inbox_start_send, inbox_start_recv) = channel(1);
-        if let Scheduler::Running { inbox_handle, .. } = self {
-            let ctx1 = ctx.clone();
-            *inbox_handle = Some(task::spawn(async move {
-                inbox_loop(ctx1, inbox_start_send, inbox_handlers).await
-            }));
-        }
-
-        let (mvbox_start_send, mvbox_start_recv) = channel(1);
-        if let Scheduler::Running { mvbox_handle, .. } = self {
-            let ctx1 = ctx.clone();
-            *mvbox_handle = Some(task::spawn(async move {
-                simple_imap_loop(
-                    ctx1,
-                    mvbox_start_send,
-                    mvbox_handlers,
-                    "configured_mvbox_folder",
-                )
-                .await
-            }));
-        }
-
-        let (sentbox_start_send, sentbox_start_recv) = channel(1);
-        if let Scheduler::Running { sentbox_handle, .. } = self {
-            let ctx1 = ctx.clone();
-            *sentbox_handle = Some(task::spawn(async move {
-                simple_imap_loop(
-                    ctx1,
-                    sentbox_start_send,
-                    sentbox_handlers,
-                    "configured_sentbox_folder",
-                )
-                .await
-            }));
-        }
-
-        let (smtp_start_send, smtp_start_recv) = channel(1);
-        if let Scheduler::Running { smtp_handle, .. } = self {
-            let ctx1 = ctx.clone();
-            *smtp_handle = Some(task::spawn(async move {
-                smtp_loop(ctx1, smtp_start_send, smtp_handlers).await
-            }));
-        }
-
-        // wait for all loops to be started
-        if let Err(err) = inbox_start_recv
-            .recv()
-            .try_join(mvbox_start_recv.recv())
-            .try_join(sentbox_start_recv.recv())
-            .try_join(smtp_start_recv.recv())
-            .await
-        {
-            error!(ctx, "failed to start scheduler: {}", err);
-        }
-
-        info!(ctx, "scheduler is running");
-    }
-
-    async fn maybe_network(&self) {
-        if !self.is_running() {
-            return;
-        }
-
-        self.interrupt_inbox(true)
-            .join(self.interrupt_mvbox(true))
-            .join(self.interrupt_sentbox(true))
-            .join(self.interrupt_smtp(true))
-            .await;
-    }
-
-    async fn interrupt_inbox(&self, probe_network: bool) {
-        if let Scheduler::Running { ref inbox, .. } = self {
-            inbox.interrupt(probe_network).await;
-        }
-    }
-
-    async fn interrupt_mvbox(&self, probe_network: bool) {
-        if let Scheduler::Running { ref mvbox, .. } = self {
-            mvbox.interrupt(probe_network).await;
-        }
-    }
-
-    async fn interrupt_sentbox(&self, probe_network: bool) {
-        if let Scheduler::Running { ref sentbox, .. } = self {
-            sentbox.interrupt(probe_network).await;
-        }
-    }
-
-    async fn interrupt_smtp(&self, probe_network: bool) {
-        if let Scheduler::Running { ref smtp, .. } = self {
-            smtp.interrupt(probe_network).await;
-        }
-    }
-
-    /// Halts the scheduler, must be called first, and then `stop`.
-    pub(crate) async fn pre_stop(&self) -> StopToken {
-        match self {
-            Scheduler::Stopped => {
-                panic!("WARN: already stopped");
-            }
-            Scheduler::Running {
-                inbox,
-                mvbox,
-                sentbox,
-                smtp,
-                ..
-            } => {
-                inbox
-                    .stop()
-                    .join(mvbox.stop())
-                    .join(sentbox.stop())
-                    .join(smtp.stop())
-                    .await;
-
-                StopToken
-            }
-        }
-    }
-
-    /// Halt the scheduler, must only be called after pre_stop.
-    pub(crate) async fn stop(&mut self, _t: StopToken) {
-        match self {
-            Scheduler::Stopped => {
-                panic!("WARN: already stopped");
-            }
-            Scheduler::Running {
-                inbox_handle,
-                mvbox_handle,
-                sentbox_handle,
-                smtp_handle,
-                ..
-            } => {
-                inbox_handle.take().expect("inbox not started").await;
-                mvbox_handle.take().expect("mvbox not started").await;
-                sentbox_handle.take().expect("sentbox not started").await;
-                smtp_handle.take().expect("smtp not started").await;
-
-                *self = Scheduler::Stopped;
-            }
-        }
-    }
-
-    /// Check if the scheduler is running.
-    pub fn is_running(&self) -> bool {
-        match self {
-            Scheduler::Running { .. } => true,
-            _ => false,
-        }
-    }
-}
-
-/// Connection state logic shared between imap and smtp connections.
-#[derive(Debug)]
-struct ConnectionState {
-    /// Channel to notify that shutdown has completed.
-    shutdown_receiver: Receiver<()>,
-    /// Channel to interrupt the whole connection.
-    stop_sender: Sender<()>,
-    /// Channel to interrupt idle.
-    idle_interrupt_sender: Sender<bool>,
-}
-
-impl ConnectionState {
-    /// Shutdown this connection completely.
-    async fn stop(&self) {
-        // Trigger shutdown of the run loop.
-        self.stop_sender.send(()).await;
-        // Wait for a notification that the run loop has been shutdown.
-        self.shutdown_receiver.recv().await.ok();
-    }
-
-    async fn interrupt(&self, probe_network: bool) {
-        // Use try_send to avoid blocking on interrupts.
-        self.idle_interrupt_sender.try_send(probe_network).ok();
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct SmtpConnectionState {
-    state: ConnectionState,
-}
-
-impl SmtpConnectionState {
-    fn new() -> (Self, SmtpConnectionHandlers) {
-        let (stop_sender, stop_receiver) = channel(1);
-        let (shutdown_sender, shutdown_receiver) = channel(1);
-        let (idle_interrupt_sender, idle_interrupt_receiver) = channel(1);
-
-        let handlers = SmtpConnectionHandlers {
-            connection: Smtp::new(),
-            stop_receiver,
-            shutdown_sender,
-            idle_interrupt_receiver,
-        };
-
-        let state = ConnectionState {
-            idle_interrupt_sender,
-            shutdown_receiver,
-            stop_sender,
-        };
-
-        let conn = SmtpConnectionState { state };
-
-        (conn, handlers)
-    }
-
-    /// Interrupt any form of idle.
-    async fn interrupt(&self, probe_network: bool) {
-        self.state.interrupt(probe_network).await;
-    }
-
-    /// Shutdown this connection completely.
-    async fn stop(&self) {
-        self.state.stop().await;
-    }
-}
-
-#[derive(Debug)]
-struct SmtpConnectionHandlers {
-    connection: Smtp,
-    stop_receiver: Receiver<()>,
-    shutdown_sender: Sender<()>,
-    idle_interrupt_receiver: Receiver<bool>,
-}
-
-#[derive(Debug)]
-pub(crate) struct ImapConnectionState {
-    state: ConnectionState,
-}
-
-impl ImapConnectionState {
-    /// Construct a new connection.
-    fn new() -> (Self, ImapConnectionHandlers) {
-        let (stop_sender, stop_receiver) = channel(1);
-        let (shutdown_sender, shutdown_receiver) = channel(1);
-        let (idle_interrupt_sender, idle_interrupt_receiver) = channel(1);
-
-        let handlers = ImapConnectionHandlers {
-            connection: Imap::new(idle_interrupt_receiver),
-            stop_receiver,
-            shutdown_sender,
-        };
-
-        let state = ConnectionState {
-            idle_interrupt_sender,
-            shutdown_receiver,
-            stop_sender,
-        };
-
-        let conn = ImapConnectionState { state };
-
-        (conn, handlers)
-    }
-
-    /// Interrupt any form of idle.
-    async fn interrupt(&self, probe_network: bool) {
-        self.state.interrupt(probe_network).await;
-    }
-
-    /// Shutdown this connection completely.
-    async fn stop(&self) {
-        self.state.stop().await;
-    }
-}
-
-#[derive(Debug)]
-struct ImapConnectionHandlers {
-    connection: Imap,
-    stop_receiver: Receiver<()>,
-    shutdown_sender: Sender<()>,
-}
-
-async fn get_watch_folder(context: &Context, config_name: impl AsRef<str>) -> Option<String> {
-    match context
-        .sql
-        .get_raw_config(context, config_name.as_ref())
-        .await
-    {
-        Some(name) => Some(name),
-        None => {
-            if config_name.as_ref() == "configured_inbox_folder" {
-                // initialized with old version, so has not set configured_inbox_folder
-                Some("INBOX".to_string())
-            } else {
-                None
-            }
-        }
-    }
-}

src/securejoin.rs

@@ -1,7 +1,5 @@
 //! Verified contact protocol implementation as [specified by countermitm project](https://countermitm.readthedocs.io/en/stable/new.html#setup-contact-protocol)
 
-use std::time::Duration;
-
 use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};
 
 use crate::aheader::EncryptPreference;
@@ -14,7 +12,7 @@ use crate::e2ee::*;
 use crate::error::{bail, Error};
 use crate::events::Event;
 use crate::headerdef::HeaderDef;
-use crate::key::{dc_normalize_fingerprint, DcKey, SignedPublicKey};
+use crate::key::{dc_normalize_fingerprint, DcKey, Key, SignedPublicKey};
 use crate::lot::LotState;
 use crate::message::Message;
 use crate::mimeparser::*;
@@ -32,7 +30,7 @@ macro_rules! joiner_progress {
             $progress >= 0 && $progress <= 1000,
             "value in range 0..1000 expected with: 0=error, 1..999=progress, 1000=success"
         );
-        $context.emit_event($crate::events::Event::SecurejoinJoinerProgress {
+        $context.call_cb($crate::events::Event::SecurejoinJoinerProgress {
             contact_id: $contact_id,
             progress: $progress,
         });
@@ -45,7 +43,7 @@ macro_rules! inviter_progress {
             $progress >= 0 && $progress <= 1000,
             "value in range 0..1000 expected with: 0=error, 1..999=progress, 1000=success"
         );
-        $context.emit_event($crate::events::Event::SecurejoinInviterProgress {
+        $context.call_cb($crate::events::Event::SecurejoinInviterProgress {
             contact_id: $contact_id,
             progress: $progress,
         });
@@ -57,7 +55,7 @@ macro_rules! get_qr_attr {
         $context
             .bob
             .read()
-            .await
+            .unwrap()
             .qr_scan
             .as_ref()
             .unwrap()
@@ -67,7 +65,7 @@ macro_rules! get_qr_attr {
     };
 }
 
-pub async fn dc_get_securejoin_qr(context: &Context, group_chat_id: ChatId) -> Option<String> {
+pub fn dc_get_securejoin_qr(context: &Context, group_chat_id: ChatId) -> Option<String> {
     /*=======================================================
     ====             Alice - the inviter side            ====
     ====   Step 1 in "Setup verified contact" protocol   ====
@@ -75,14 +73,13 @@ pub async fn dc_get_securejoin_qr(context: &Context, group_chat_id: ChatId) -> O
 
     let fingerprint: String;
 
-    ensure_secret_key_exists(context).await.ok();
+    ensure_secret_key_exists(context).ok();
 
     // invitenumber will be used to allow starting the handshake,
     // auth will be used to verify the fingerprint
-    let invitenumber =
-        token::lookup_or_new(context, token::Namespace::InviteNumber, group_chat_id).await;
-    let auth = token::lookup_or_new(context, token::Namespace::Auth, group_chat_id).await;
-    let self_addr = match context.get_config(Config::ConfiguredAddr).await {
+    let invitenumber = token::lookup_or_new(context, token::Namespace::InviteNumber, group_chat_id);
+    let auth = token::lookup_or_new(context, token::Namespace::Auth, group_chat_id);
+    let self_addr = match context.get_config(Config::ConfiguredAddr) {
         Some(addr) => addr,
         None => {
             error!(context, "Not configured, cannot generate QR code.",);
@@ -90,12 +87,9 @@ pub async fn dc_get_securejoin_qr(context: &Context, group_chat_id: ChatId) -> O
         }
     };
 
-    let self_name = context
-        .get_config(Config::Displayname)
-        .await
-        .unwrap_or_default();
+    let self_name = context.get_config(Config::Displayname).unwrap_or_default();
 
-    fingerprint = match get_self_fingerprint(context).await {
+    fingerprint = match get_self_fingerprint(context) {
         Some(fp) => fp,
         None => {
             return None;
@@ -109,7 +103,7 @@ pub async fn dc_get_securejoin_qr(context: &Context, group_chat_id: ChatId) -> O
 
     let qr = if !group_chat_id.is_unset() {
         // parameters used: a=g=x=i=s=
-        if let Ok(chat) = Chat::load_from_db(context, group_chat_id).await {
+        if let Ok(chat) = Chat::load_from_db(context, group_chat_id) {
             let group_name = chat.get_name();
             let group_name_urlencoded =
                 utf8_percent_encode(&group_name, NON_ALPHANUMERIC).to_string();
@@ -140,9 +134,9 @@ pub async fn dc_get_securejoin_qr(context: &Context, group_chat_id: ChatId) -> O
     qr
 }
 
-async fn get_self_fingerprint(context: &Context) -> Option<String> {
-    match SignedPublicKey::load_self(context).await {
-        Ok(key) => Some(key.fingerprint().hex()),
+fn get_self_fingerprint(context: &Context) -> Option<String> {
+    match SignedPublicKey::load_self(context) {
+        Ok(key) => Some(Key::from(key).fingerprint()),
         Err(_) => {
             warn!(context, "get_self_fingerprint(): failed to load key");
             None
@@ -150,48 +144,35 @@ async fn get_self_fingerprint(context: &Context) -> Option<String> {
     }
 }
 
-async fn cleanup(
-    context: &Context,
-    contact_chat_id: ChatId,
-    ongoing_allocated: bool,
-    join_vg: bool,
-) -> ChatId {
-    let mut bob = context.bob.write().await;
-    bob.expects = 0;
-    let ret_chat_id: ChatId = if bob.status == DC_BOB_SUCCESS {
-        if join_vg {
-            chat::get_chat_id_by_grpid(
-                context,
-                bob.qr_scan.as_ref().unwrap().text2.as_ref().unwrap(),
-            )
-            .await
-            .unwrap_or((ChatId::new(0), false, Blocked::Not))
-            .0
-        } else {
-            contact_chat_id
-        }
-    } else {
-        ChatId::new(0)
-    };
-    bob.qr_scan = None;
-
-    if ongoing_allocated {
-        context.free_ongoing().await;
-    }
-    ret_chat_id
-}
-
 /// Take a scanned QR-code and do the setup-contact/join-group handshake.
 /// See the ffi-documentation for more details.
-pub async fn dc_join_securejoin(context: &Context, qr: &str) -> ChatId {
-    if context.alloc_ongoing().await.is_err() {
-        return cleanup(&context, ChatId::new(0), false, false).await;
-    }
+pub fn dc_join_securejoin(context: &Context, qr: &str) -> ChatId {
+    let cleanup =
+        |context: &Context, contact_chat_id: ChatId, ongoing_allocated: bool, join_vg: bool| {
+            let mut bob = context.bob.write().unwrap();
+            bob.expects = 0;
+            let ret_chat_id: ChatId = if bob.status == DC_BOB_SUCCESS {
+                if join_vg {
+                    chat::get_chat_id_by_grpid(
+                        context,
+                        bob.qr_scan.as_ref().unwrap().text2.as_ref().unwrap(),
+                    )
+                    .unwrap_or((ChatId::new(0), false, Blocked::Not))
+                    .0
+                } else {
+                    contact_chat_id
+                }
+            } else {
+                ChatId::new(0)
+            };
+            bob.qr_scan = None;
 
-    securejoin(context, qr).await
-}
+            if ongoing_allocated {
+                context.free_ongoing();
+            }
+            ret_chat_id
+        };
 
-async fn securejoin(context: &Context, qr: &str) -> ChatId {
     /*========================================================
     ====             Bob - the joiner's side             =====
     ====   Step 2 in "Setup verified contact" protocol   =====
@@ -201,26 +182,29 @@ async fn securejoin(context: &Context, qr: &str) -> ChatId {
     let mut join_vg: bool = false;
 
     info!(context, "Requesting secure-join ...",);
-    ensure_secret_key_exists(context).await.ok();
-    let qr_scan = check_qr(context, &qr).await;
+    ensure_secret_key_exists(context).ok();
+    if !context.alloc_ongoing() {
+        return cleanup(&context, contact_chat_id, false, join_vg);
+    }
+    let qr_scan = check_qr(context, &qr);
     if qr_scan.state != LotState::QrAskVerifyContact && qr_scan.state != LotState::QrAskVerifyGroup
     {
         error!(context, "Unknown QR code.",);
-        return cleanup(&context, contact_chat_id, true, join_vg).await;
+        return cleanup(&context, contact_chat_id, true, join_vg);
     }
-    contact_chat_id = match chat::create_by_contact_id(context, qr_scan.id).await {
+    contact_chat_id = match chat::create_by_contact_id(context, qr_scan.id) {
         Ok(chat_id) => chat_id,
         Err(_) => {
             error!(context, "Unknown contact.");
-            return cleanup(&context, contact_chat_id, true, join_vg).await;
+            return cleanup(&context, contact_chat_id, true, join_vg);
         }
     };
-    if context.shall_stop_ongoing().await {
-        return cleanup(&context, contact_chat_id, true, join_vg).await;
+    if context.shall_stop_ongoing() {
+        return cleanup(&context, contact_chat_id, true, join_vg);
     }
     join_vg = qr_scan.get_state() == LotState::QrAskVerifyGroup;
     {
-        let mut bob = context.bob.write().await;
+        let mut bob = context.bob.write().unwrap();
         bob.status = 0;
         bob.qr_scan = Some(qr_scan);
     }
@@ -229,7 +213,7 @@ async fn securejoin(context: &Context, qr: &str) -> ChatId {
         context
             .bob
             .read()
-            .await
+            .unwrap()
             .qr_scan
             .as_ref()
             .unwrap()
@@ -237,22 +221,16 @@ async fn securejoin(context: &Context, qr: &str) -> ChatId {
             .as_ref()
             .unwrap(),
         contact_chat_id,
-    )
-    .await
-    {
+    ) {
         // the scanned fingerprint matches Alice's key,
         // we can proceed to step 4b) directly and save two mails
         info!(context, "Taking protocol shortcut.");
-        context.bob.write().await.expects = DC_VC_CONTACT_CONFIRM;
-        joiner_progress!(
-            context,
-            chat_id_2_contact_id(context, contact_chat_id).await,
-            400
-        );
-        let own_fingerprint = get_self_fingerprint(context).await.unwrap_or_default();
+        context.bob.write().unwrap().expects = DC_VC_CONTACT_CONFIRM;
+        joiner_progress!(context, chat_id_2_contact_id(context, contact_chat_id), 400);
+        let own_fingerprint = get_self_fingerprint(context).unwrap_or_default();
 
         // Bob -> Alice
-        if let Err(err) = send_handshake_msg(
+        send_handshake_msg(
             context,
             contact_chat_id,
             if join_vg {
@@ -267,53 +245,43 @@ async fn securejoin(context: &Context, qr: &str) -> ChatId {
             } else {
                 "".to_string()
             },
-        )
-        .await
-        {
-            error!(context, "failed to send handshake message: {}", err);
-            return cleanup(&context, contact_chat_id, true, join_vg).await;
-        }
+        );
     } else {
-        context.bob.write().await.expects = DC_VC_AUTH_REQUIRED;
+        context.bob.write().unwrap().expects = DC_VC_AUTH_REQUIRED;
 
         // Bob -> Alice
-        if let Err(err) = send_handshake_msg(
+        send_handshake_msg(
             context,
             contact_chat_id,
             if join_vg { "vg-request" } else { "vc-request" },
             get_qr_attr!(context, invitenumber),
             None,
             "",
-        )
-        .await
-        {
-            error!(context, "failed to send handshake message: {}", err);
-            return cleanup(&context, contact_chat_id, true, join_vg).await;
-        }
+        );
     }
 
     if join_vg {
         // for a group-join, wait until the secure-join is done and the group is created
-        while !context.shall_stop_ongoing().await {
-            async_std::task::sleep(Duration::from_millis(50)).await;
+        while !context.shall_stop_ongoing() {
+            std::thread::sleep(std::time::Duration::from_millis(200));
         }
-        cleanup(&context, contact_chat_id, true, join_vg).await
+        cleanup(&context, contact_chat_id, true, join_vg)
     } else {
         // for a one-to-one-chat, the chat is already known, return the chat-id,
         // the verification runs in background
-        context.free_ongoing().await;
+        context.free_ongoing();
         contact_chat_id
     }
 }
 
-async fn send_handshake_msg(
+fn send_handshake_msg(
     context: &Context,
     contact_chat_id: ChatId,
     step: &str,
     param2: impl AsRef<str>,
     fingerprint: Option<String>,
     grpid: impl AsRef<str>,
-) -> Result<(), HandshakeError> {
+) {
     let mut msg = Message::default();
     msg.viewtype = Viewtype::Text;
     msg.text = Some(format!("Secure-Join: {}", step));
@@ -341,16 +309,12 @@ async fn send_handshake_msg(
     } else {
         msg.param.set_int(Param::GuaranteeE2ee, 1);
     }
-
-    chat::send_msg(context, contact_chat_id, &mut msg)
-        .await
-        .map_err(HandshakeError::MsgSendFailed)?;
-
-    Ok(())
+    // TODO. handle cleanup on error
+    chat::send_msg(context, contact_chat_id, &mut msg).unwrap_or_default();
 }
 
-async fn chat_id_2_contact_id(context: &Context, contact_chat_id: ChatId) -> u32 {
-    let contacts = chat::get_chat_contacts(context, contact_chat_id).await;
+fn chat_id_2_contact_id(context: &Context, contact_chat_id: ChatId) -> u32 {
+    let contacts = chat::get_chat_contacts(context, contact_chat_id);
     if contacts.len() == 1 {
         contacts[0]
     } else {
@@ -358,16 +322,17 @@ async fn chat_id_2_contact_id(context: &Context, contact_chat_id: ChatId) -> u32
     }
 }
 
-async fn fingerprint_equals_sender(
+fn fingerprint_equals_sender(
     context: &Context,
     fingerprint: impl AsRef<str>,
     contact_chat_id: ChatId,
 ) -> bool {
-    let contacts = chat::get_chat_contacts(context, contact_chat_id).await;
+    let contacts = chat::get_chat_contacts(context, contact_chat_id);
 
     if contacts.len() == 1 {
-        if let Ok(contact) = Contact::load_from_db(context, contacts[0]).await {
-            if let Some(peerstate) = Peerstate::from_addr(context, contact.get_addr()).await {
+        if let Ok(contact) = Contact::load_from_db(context, contacts[0]) {
+            if let Some(peerstate) = Peerstate::from_addr(context, &context.sql, contact.get_addr())
+            {
                 let fingerprint_normalized = dc_normalize_fingerprint(fingerprint.as_ref());
                 if peerstate.public_key_fingerprint.is_some()
                     && &fingerprint_normalized == peerstate.public_key_fingerprint.as_ref().unwrap()
@@ -395,8 +360,6 @@ pub(crate) enum HandshakeError {
     ChatNotFound { group: String },
     #[error("No configured self address found")]
     NoSelfAddr,
-    #[error("Failed to send message")]
-    MsgSendFailed(#[source] Error),
 }
 
 /// What to do with a Secure-Join handshake message after it was handled.
@@ -423,7 +386,7 @@ pub(crate) enum HandshakeMessage {
 /// When handle_securejoin_handshake() is called,
 /// the message is not yet filed in the database;
 /// this is done by receive_imf() later on as needed.
-pub(crate) async fn handle_securejoin_handshake(
+pub(crate) fn handle_securejoin_handshake(
     context: &Context,
     mime_message: &MimeMessage,
     contact_id: u32,
@@ -441,10 +404,10 @@ pub(crate) async fn handle_securejoin_handshake(
     );
 
     let contact_chat_id =
-        match chat::create_or_lookup_by_contact_id(context, contact_id, Blocked::Not).await {
+        match chat::create_or_lookup_by_contact_id(context, contact_id, Blocked::Not) {
             Ok((chat_id, blocked)) => {
                 if blocked != Blocked::Not {
-                    chat_id.unblock(context).await;
+                    chat_id.unblock(context);
                 }
                 chat_id
             }
@@ -476,7 +439,7 @@ pub(crate) async fn handle_securejoin_handshake(
                     return Ok(HandshakeMessage::Ignore);
                 }
             };
-            if !token::exists(context, token::Namespace::InviteNumber, &invitenumber).await {
+            if !token::exists(context, token::Namespace::InviteNumber, &invitenumber) {
                 warn!(context, "Secure-join denied (bad invitenumber).");
                 return Ok(HandshakeMessage::Ignore);
             }
@@ -492,8 +455,7 @@ pub(crate) async fn handle_securejoin_handshake(
                 "",
                 None,
                 "",
-            )
-            .await?;
+            );
             Ok(HandshakeMessage::Done)
         }
         "vg-auth-required" | "vc-auth-required" => {
@@ -504,7 +466,7 @@ pub(crate) async fn handle_securejoin_handshake(
 
             // verify that Alice's Autocrypt key and fingerprint matches the QR-code
             let cond = {
-                let bob = context.bob.read().await;
+                let bob = context.bob.read().unwrap();
                 let scan = bob.qr_scan.as_ref();
                 scan.is_none()
                     || bob.expects != DC_VC_AUTH_REQUIRED
@@ -528,29 +490,25 @@ pub(crate) async fn handle_securejoin_handshake(
                     } else {
                         "Not encrypted."
                     },
-                )
-                .await;
-                context.bob.write().await.status = 0; // secure-join failed
-                context.stop_ongoing().await;
+                );
+                context.bob.write().unwrap().status = 0; // secure-join failed
+                context.stop_ongoing();
                 return Ok(HandshakeMessage::Ignore);
             }
-            if !fingerprint_equals_sender(context, &scanned_fingerprint_of_alice, contact_chat_id)
-                .await
-            {
+            if !fingerprint_equals_sender(context, &scanned_fingerprint_of_alice, contact_chat_id) {
                 could_not_establish_secure_connection(
                     context,
                     contact_chat_id,
                     "Fingerprint mismatch on joiner-side.",
-                )
-                .await;
-                context.bob.write().await.status = 0; // secure-join failed
-                context.stop_ongoing().await;
+                );
+                context.bob.write().unwrap().status = 0; // secure-join failed
+                context.stop_ongoing();
                 return Ok(HandshakeMessage::Ignore);
             }
             info!(context, "Fingerprint verified.",);
-            let own_fingerprint = get_self_fingerprint(context).await.unwrap();
+            let own_fingerprint = get_self_fingerprint(context).unwrap();
             joiner_progress!(context, contact_id, 400);
-            context.bob.write().await.expects = DC_VC_CONTACT_CONFIRM;
+            context.bob.write().unwrap().expects = DC_VC_CONTACT_CONFIRM;
 
             // Bob -> Alice
             send_handshake_msg(
@@ -564,8 +522,7 @@ pub(crate) async fn handle_securejoin_handshake(
                 } else {
                     "".to_string()
                 },
-            )
-            .await?;
+            );
             Ok(HandshakeMessage::Done)
         }
         "vg-request-with-auth" | "vc-request-with-auth" => {
@@ -583,8 +540,7 @@ pub(crate) async fn handle_securejoin_handshake(
                         context,
                         contact_chat_id,
                         "Fingerprint not provided.",
-                    )
-                    .await;
+                    );
                     return Ok(HandshakeMessage::Ignore);
                 }
             };
@@ -593,17 +549,15 @@ pub(crate) async fn handle_securejoin_handshake(
                     context,
                     contact_chat_id,
                     "Auth not encrypted.",
-                )
-                .await;
+                );
                 return Ok(HandshakeMessage::Ignore);
             }
-            if !fingerprint_equals_sender(context, &fingerprint, contact_chat_id).await {
+            if !fingerprint_equals_sender(context, &fingerprint, contact_chat_id) {
                 could_not_establish_secure_connection(
                     context,
                     contact_chat_id,
                     "Fingerprint mismatch on inviter-side.",
-                )
-                .await;
+                );
                 return Ok(HandshakeMessage::Ignore);
             }
             info!(context, "Fingerprint verified.",);
@@ -615,28 +569,25 @@ pub(crate) async fn handle_securejoin_handshake(
                         context,
                         contact_chat_id,
                         "Auth not provided.",
-                    )
-                    .await;
+                    );
                     return Ok(HandshakeMessage::Ignore);
                 }
             };
-            if !token::exists(context, token::Namespace::Auth, &auth_0).await {
-                could_not_establish_secure_connection(context, contact_chat_id, "Auth invalid.")
-                    .await;
+            if !token::exists(context, token::Namespace::Auth, &auth_0) {
+                could_not_establish_secure_connection(context, contact_chat_id, "Auth invalid.");
                 return Ok(HandshakeMessage::Ignore);
             }
-            if mark_peer_as_verified(context, fingerprint).await.is_err() {
+            if mark_peer_as_verified(context, fingerprint).is_err() {
                 could_not_establish_secure_connection(
                     context,
                     contact_chat_id,
                     "Fingerprint mismatch on inviter-side.",
-                )
-                .await;
+                );
                 return Ok(HandshakeMessage::Ignore);
             }
-            Contact::scaleup_origin_by_id(context, contact_id, Origin::SecurejoinInvited).await;
+            Contact::scaleup_origin_by_id(context, contact_id, Origin::SecurejoinInvited);
             info!(context, "Auth verified.",);
-            secure_connection_established(context, contact_chat_id).await;
+            secure_connection_established(context, contact_chat_id);
             emit_event!(context, Event::ContactsChanged(Some(contact_id)));
             inviter_progress!(context, contact_id, 600);
             if join_vg {
@@ -650,11 +601,10 @@ pub(crate) async fn handle_securejoin_handshake(
                         return Ok(HandshakeMessage::Ignore);
                     }
                 };
-                match chat::get_chat_id_by_grpid(context, field_grpid).await {
+                match chat::get_chat_id_by_grpid(context, field_grpid) {
                     Ok((group_chat_id, _, _)) => {
                         if let Err(err) =
                             chat::add_contact_to_chat_ex(context, group_chat_id, contact_id, true)
-                                .await
                         {
                             error!(context, "failed to add contact: {}", err);
                         }
@@ -675,9 +625,7 @@ pub(crate) async fn handle_securejoin_handshake(
                     "",
                     Some(fingerprint.clone()),
                     "",
-                )
-                .await?;
-
+                );
                 inviter_progress!(context, contact_id, 1000);
             }
             Ok(HandshakeMessage::Ignore) // "Done" would delete the message and break multi-device (the key from Autocrypt-header is needed)
@@ -693,12 +641,12 @@ pub(crate) async fn handle_securejoin_handshake(
                 HandshakeMessage::Ignore
             };
 
-            if context.bob.read().await.expects != DC_VC_CONTACT_CONFIRM {
+            if context.bob.read().unwrap().expects != DC_VC_CONTACT_CONFIRM {
                 info!(context, "Message belongs to a different handshake.",);
                 return Ok(abort_retval);
             }
             let cond = {
-                let bob = context.bob.read().await;
+                let bob = context.bob.read().unwrap();
                 let scan = bob.qr_scan.as_ref();
                 scan.is_none() || (join_vg && scan.unwrap().state != LotState::QrAskVerifyGroup)
             };
@@ -719,7 +667,6 @@ pub(crate) async fn handle_securejoin_handshake(
                 // only after we have returned.  It does not impact
                 // the security invariants of secure-join however.
                 let (_, is_verified_group, _) = chat::get_chat_id_by_grpid(context, &group_id)
-                    .await
                     .unwrap_or((ChatId::new(0), false, Blocked::Not));
                 // when joining a non-verified group
                 // the vg-member-added message may be unencrypted
@@ -737,25 +684,20 @@ pub(crate) async fn handle_securejoin_handshake(
                     context,
                     contact_chat_id,
                     "Contact confirm message not encrypted.",
-                )
-                .await;
-                context.bob.write().await.status = 0;
+                );
+                context.bob.write().unwrap().status = 0;
                 return Ok(abort_retval);
             }
 
-            if mark_peer_as_verified(context, &scanned_fingerprint_of_alice)
-                .await
-                .is_err()
-            {
+            if mark_peer_as_verified(context, &scanned_fingerprint_of_alice).is_err() {
                 could_not_establish_secure_connection(
                     context,
                     contact_chat_id,
                     "Fingerprint mismatch on joiner-side.",
-                )
-                .await;
+                );
                 return Ok(abort_retval);
             }
-            Contact::scaleup_origin_by_id(context, contact_id, Origin::SecurejoinJoined).await;
+            Contact::scaleup_origin_by_id(context, contact_id, Origin::SecurejoinJoined);
             emit_event!(context, Event::ContactsChanged(None));
             let cg_member_added = mime_message
                 .get(HeaderDef::ChatGroupMemberAdded)
@@ -764,14 +706,13 @@ pub(crate) async fn handle_securejoin_handshake(
             if join_vg
                 && !context
                     .is_self_addr(cg_member_added)
-                    .await
                     .map_err(|_| HandshakeError::NoSelfAddr)?
             {
                 info!(context, "Message belongs to a different handshake (scaled up contact anyway to allow creation of group).");
                 return Ok(abort_retval);
             }
-            secure_connection_established(context, contact_chat_id).await;
-            context.bob.write().await.expects = 0;
+            secure_connection_established(context, contact_chat_id);
+            context.bob.write().unwrap().expects = 0;
 
             // Bob -> Alice
             send_handshake_msg(
@@ -785,11 +726,10 @@ pub(crate) async fn handle_securejoin_handshake(
                 "",
                 Some(scanned_fingerprint_of_alice),
                 "",
-            )
-            .await?;
+            );
 
-            context.bob.write().await.status = 1;
-            context.stop_ongoing().await;
+            context.bob.write().unwrap().status = 1;
+            context.stop_ongoing();
             Ok(if join_vg {
                 HandshakeMessage::Propagate
             } else {
@@ -802,8 +742,8 @@ pub(crate) async fn handle_securejoin_handshake(
             ====  Step 8 in "Out-of-band verified groups" protocol  ====
             ==========================================================*/
 
-            if let Ok(contact) = Contact::get_by_id(context, contact_id).await {
-                if contact.is_verified(context).await == VerifiedStatus::Unverified {
+            if let Ok(contact) = Contact::get_by_id(context, contact_id) {
+                if contact.is_verified(context) == VerifiedStatus::Unverified {
                     warn!(context, "{} invalid.", step);
                     return Ok(HandshakeMessage::Ignore);
                 }
@@ -814,7 +754,7 @@ pub(crate) async fn handle_securejoin_handshake(
                         .get(HeaderDef::SecureJoinGroup)
                         .map(|s| s.as_str())
                         .unwrap_or_else(|| "");
-                    if let Err(err) = chat::get_chat_id_by_grpid(context, &field_grpid).await {
+                    if let Err(err) = chat::get_chat_id_by_grpid(context, &field_grpid) {
                         warn!(context, "Failed to lookup chat_id from grpid: {}", err);
                         return Err(HandshakeError::ChatNotFound {
                             group: field_grpid.to_string(),
@@ -851,7 +791,7 @@ pub(crate) async fn handle_securejoin_handshake(
 ///   the joining device has marked the peer as verified on vg-member-added/vc-contact-confirm
 ///   before sending vg-member-added-received - so, if we observe vg-member-added-received,
 ///   we can mark the peer as verified as well.
-pub(crate) async fn observe_securejoin_on_other_device(
+pub(crate) fn observe_securejoin_on_other_device(
     context: &Context,
     mime_message: &MimeMessage,
     contact_id: u32,
@@ -865,10 +805,10 @@ pub(crate) async fn observe_securejoin_on_other_device(
     info!(context, "observing secure-join message \'{}\'", step);
 
     let contact_chat_id =
-        match chat::create_or_lookup_by_contact_id(context, contact_id, Blocked::Not).await {
+        match chat::create_or_lookup_by_contact_id(context, contact_id, Blocked::Not) {
             Ok((chat_id, blocked)) => {
                 if blocked != Blocked::Not {
-                    chat_id.unblock(context).await;
+                    chat_id.unblock(context);
                 }
                 chat_id
             }
@@ -888,14 +828,13 @@ pub(crate) async fn observe_securejoin_on_other_device(
             if !encrypted_and_signed(
                 context,
                 mime_message,
-                get_self_fingerprint(context).await.unwrap_or_default(),
+                get_self_fingerprint(context).unwrap_or_default(),
             ) {
                 could_not_establish_secure_connection(
                     context,
                     contact_chat_id,
                     "Message not encrypted correctly.",
-                )
-                .await;
+                );
                 return Ok(HandshakeMessage::Ignore);
             }
             let fingerprint = match mime_message.get(HeaderDef::SecureJoinFingerprint) {
@@ -905,18 +844,16 @@ pub(crate) async fn observe_securejoin_on_other_device(
                         context,
                         contact_chat_id,
                         "Fingerprint not provided, please update Delta Chat on all your devices.",
-                    )
-                    .await;
+                    );
                     return Ok(HandshakeMessage::Ignore);
                 }
             };
-            if mark_peer_as_verified(context, fingerprint).await.is_err() {
+            if mark_peer_as_verified(context, fingerprint).is_err() {
                 could_not_establish_secure_connection(
                     context,
                     contact_chat_id,
                     format!("Fingerprint mismatch on observing {}.", step).as_ref(),
-                )
-                .await;
+                );
                 return Ok(HandshakeMessage::Ignore);
             }
             Ok(if step.as_str() == "vg-member-added" {
@@ -929,50 +866,42 @@ pub(crate) async fn observe_securejoin_on_other_device(
     }
 }
 
-async fn secure_connection_established(context: &Context, contact_chat_id: ChatId) {
-    let contact_id: u32 = chat_id_2_contact_id(context, contact_chat_id).await;
-    let contact = Contact::get_by_id(context, contact_id).await;
-
+fn secure_connection_established(context: &Context, contact_chat_id: ChatId) {
+    let contact_id: u32 = chat_id_2_contact_id(context, contact_chat_id);
+    let contact = Contact::get_by_id(context, contact_id);
     let addr = if let Ok(ref contact) = contact {
         contact.get_addr()
     } else {
         "?"
     };
-    let msg = context
-        .stock_string_repl_str(StockMessage::ContactVerified, addr)
-        .await;
-    chat::add_info_msg(context, contact_chat_id, msg).await;
+    let msg = context.stock_string_repl_str(StockMessage::ContactVerified, addr);
+    chat::add_info_msg(context, contact_chat_id, msg);
     emit_event!(context, Event::ChatModified(contact_chat_id));
 }
 
-async fn could_not_establish_secure_connection(
+fn could_not_establish_secure_connection(
     context: &Context,
     contact_chat_id: ChatId,
     details: &str,
 ) {
-    let contact_id = chat_id_2_contact_id(context, contact_chat_id).await;
-    let contact = Contact::get_by_id(context, contact_id).await;
-    let msg = context
-        .stock_string_repl_str(
-            StockMessage::ContactNotVerified,
-            if let Ok(ref contact) = contact {
-                contact.get_addr()
-            } else {
-                "?"
-            },
-        )
-        .await;
+    let contact_id = chat_id_2_contact_id(context, contact_chat_id);
+    let contact = Contact::get_by_id(context, contact_id);
+    let msg = context.stock_string_repl_str(
+        StockMessage::ContactNotVerified,
+        if let Ok(ref contact) = contact {
+            contact.get_addr()
+        } else {
+            "?"
+        },
+    );
 
-    chat::add_info_msg(context, contact_chat_id, &msg).await;
+    chat::add_info_msg(context, contact_chat_id, &msg);
     error!(context, "{} ({})", &msg, details);
 }
 
-async fn mark_peer_as_verified(
-    context: &Context,
-    fingerprint: impl AsRef<str>,
-) -> Result<(), Error> {
+fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Result<(), Error> {
     if let Some(ref mut peerstate) =
-        Peerstate::from_fingerprint(context, &context.sql, fingerprint.as_ref()).await
+        Peerstate::from_fingerprint(context, &context.sql, fingerprint.as_ref())
     {
         if peerstate.set_verified(
             PeerstateKeyType::PublicKey,
@@ -983,7 +912,6 @@ async fn mark_peer_as_verified(
             peerstate.to_save = Some(ToSave::All);
             peerstate
                 .save_to_db(&context.sql, false)
-                .await
                 .unwrap_or_default();
             return Ok(());
         }
@@ -1027,25 +955,18 @@ fn encrypted_and_signed(
     }
 }
 
-pub async fn handle_degrade_event(
-    context: &Context,
-    peerstate: &Peerstate<'_>,
-) -> Result<(), Error> {
+pub fn handle_degrade_event(context: &Context, peerstate: &Peerstate) -> Result<(), Error> {
     // - we do not issue an warning for DC_DE_ENCRYPTION_PAUSED as this is quite normal
     // - currently, we do not issue an extra warning for DC_DE_VERIFICATION_LOST - this always comes
     //   together with DC_DE_FINGERPRINT_CHANGED which is logged, the idea is not to bother
     //   with things they cannot fix, so the user is just kicked from the verified group
     //   (and he will know this and can fix this)
     if Some(DegradeEvent::FingerprintChanged) == peerstate.degrade_event {
-        let contact_id: i32 = match context
-            .sql
-            .query_get_value(
-                context,
-                "SELECT id FROM contacts WHERE addr=?;",
-                paramsv![peerstate.addr],
-            )
-            .await
-        {
+        let contact_id: i32 = match context.sql.query_get_value(
+            context,
+            "SELECT id FROM contacts WHERE addr=?;",
+            params![&peerstate.addr],
+        ) {
             None => bail!(
                 "contact with peerstate.addr {:?} not found",
                 &peerstate.addr
@@ -1055,14 +976,12 @@ pub async fn handle_degrade_event(
         if contact_id > 0 {
             let (contact_chat_id, _) =
                 chat::create_or_lookup_by_contact_id(context, contact_id as u32, Blocked::Deaddrop)
-                    .await
                     .unwrap_or_default();
 
             let msg = context
-                .stock_string_repl_str(StockMessage::ContactSetupChanged, peerstate.addr.clone())
-                .await;
+                .stock_string_repl_str(StockMessage::ContactSetupChanged, peerstate.addr.clone());
 
-            chat::add_info_msg(context, contact_chat_id, msg).await;
+            chat::add_info_msg(context, contact_chat_id, msg);
             emit_event!(context, Event::ChatModified(contact_chat_id));
         }
     }

src/smtp/mod.rs

@@ -65,16 +65,16 @@ impl Smtp {
     }
 
     /// Disconnect the SMTP transport and drop it entirely.
-    pub async fn disconnect(&mut self) {
+    pub fn disconnect(&mut self) {
         if let Some(mut transport) = self.transport.take() {
-            transport.close().await.ok();
+            async_std::task::block_on(transport.close()).ok();
         }
         self.last_success = None;
     }
 
     /// Return true if smtp was connected but is not known to
     /// have been successfully used the last 60 seconds
-    pub async fn has_maybe_stale_connection(&self) -> bool {
+    pub fn has_maybe_stale_connection(&self) -> bool {
         if let Some(last_success) = self.last_success {
             Instant::now().duration_since(last_success).as_secs() > 60
         } else {
@@ -83,7 +83,7 @@ impl Smtp {
     }
 
     /// Check whether we are connected.
-    pub async fn is_connected(&self) -> bool {
+    pub fn is_connected(&self) -> bool {
         self.transport
             .as_ref()
             .map(|t| t.is_connected())
@@ -91,14 +91,18 @@ impl Smtp {
     }
 
     /// Connect using the provided login params.
-    pub async fn connect(&mut self, context: &Context, lp: &LoginParam) -> Result<()> {
-        if self.is_connected().await {
+    pub fn connect(&mut self, context: &Context, lp: &LoginParam) -> Result<()> {
+        async_std::task::block_on(self.inner_connect(context, lp))
+    }
+
+    async fn inner_connect(&mut self, context: &Context, lp: &LoginParam) -> Result<()> {
+        if self.is_connected() {
             warn!(context, "SMTP already connected.");
             return Ok(());
         }
 
         if lp.send_server.is_empty() || lp.send_port == 0 {
-            context.emit_event(Event::ErrorNetwork("SMTP bad parameters.".into()));
+            context.call_cb(Event::ErrorNetwork("SMTP bad parameters.".into()));
             return Err(Error::BadParameters);
         }
 
@@ -107,7 +111,6 @@ impl Smtp {
                 address: lp.addr.clone(),
                 error: err,
             })?;
-
         self.from = Some(from);
 
         let domain = &lp.send_server;
@@ -120,7 +123,7 @@ impl Smtp {
             // oauth2
             let addr = &lp.addr;
             let send_pw = &lp.send_pw;
-            let access_token = dc_get_oauth2_access_token(context, addr, send_pw, false).await;
+            let access_token = dc_get_oauth2_access_token(context, addr, send_pw, false);
             if access_token.is_none() {
                 return Err(Error::Oauth2Error {
                     address: addr.to_string(),
@@ -167,23 +170,22 @@ impl Smtp {
             .timeout(Some(Duration::from_secs(SMTP_TIMEOUT)));
 
         let mut trans = client.into_transport();
-        if let Err(err) = trans.connect().await {
-            let message = context
-                .stock_string_repl_str2(
+
+        trans.connect().await.map_err(|err| {
+            let message = {
+                context.stock_string_repl_str2(
                     StockMessage::ServerResponse,
                     format!("SMTP {}:{}", domain, port),
                     err.to_string(),
                 )
-                .await;
-
+            };
             emit_event!(context, Event::ErrorNetwork(message));
-            return Err(Error::ConnectionFailure(err));
-        }
+            Error::ConnectionFailure(err)
+        })?;
 
         self.transport = Some(trans);
         self.last_success = Some(Instant::now());
-
-        context.emit_event(Event::SmtpConnected(format!(
+        context.call_cb(Event::SmtpConnected(format!(
             "SMTP-LOGIN as {} ok",
             lp.send_user,
         )));

src/smtp/send.rs

@@ -49,7 +49,7 @@ impl Smtp {
         if let Some(ref mut transport) = self.transport {
             transport.send(mail).await.map_err(Error::SendError)?;
 
-            context.emit_event(Event::SmtpMessageSent(format!(
+            context.call_cb(Event::SmtpMessageSent(format!(
                 "Message len={} was smtp-sent to {}",
                 message_len, recipients_display
             )));

src/stock.rs

@@ -197,7 +197,7 @@ impl StockMessage {
 impl Context {
     /// Set the stock string for the [StockMessage].
     ///
-    pub async fn set_stock_translation(
+    pub fn set_stock_translation(
         &self,
         id: StockMessage,
         stockstring: String,
@@ -218,7 +218,7 @@ impl Context {
         }
         self.translated_stockstrings
             .write()
-            .await
+            .unwrap()
             .insert(id as usize, stockstring);
         Ok(())
     }
@@ -227,11 +227,11 @@ impl Context {
     ///
     /// Return a translation (if it was set with set_stock_translation before)
     /// or a default (English) string.
-    pub async fn stock_str(&self, id: StockMessage) -> Cow<'_, str> {
+    pub fn stock_str(&self, id: StockMessage) -> Cow<str> {
         match self
             .translated_stockstrings
             .read()
-            .await
+            .unwrap()
             .get(&(id as usize))
         {
             Some(ref x) => Cow::Owned((*x).to_string()),
@@ -244,9 +244,8 @@ impl Context {
     /// This replaces both the *first* `%1$s`, `%1$d` and `%1$@`
     /// placeholders with the provided string.
     /// (the `%1$@` variant is used on iOS, the other are used on Android and Desktop)
-    pub async fn stock_string_repl_str(&self, id: StockMessage, insert: impl AsRef<str>) -> String {
+    pub fn stock_string_repl_str(&self, id: StockMessage, insert: impl AsRef<str>) -> String {
         self.stock_str(id)
-            .await
             .replacen("%1$s", insert.as_ref(), 1)
             .replacen("%1$d", insert.as_ref(), 1)
             .replacen("%1$@", insert.as_ref(), 1)
@@ -256,9 +255,8 @@ impl Context {
     ///
     /// Like [Context::stock_string_repl_str] but substitute the placeholders
     /// with an integer.
-    pub async fn stock_string_repl_int(&self, id: StockMessage, insert: i32) -> String {
+    pub fn stock_string_repl_int(&self, id: StockMessage, insert: i32) -> String {
         self.stock_string_repl_str(id, format!("{}", insert).as_str())
-            .await
     }
 
     /// Return stock string, replacing 2 placeholders with provided string.
@@ -267,14 +265,13 @@ impl Context {
     /// placeholders with the string in `insert` and does the same for
     /// `%2$s`, `%2$d` and `%2$@` for `insert2`.
     /// (the `%1$@` variant is used on iOS, the other are used on Android and Desktop)
-    pub async fn stock_string_repl_str2(
+    pub fn stock_string_repl_str2(
         &self,
         id: StockMessage,
         insert: impl AsRef<str>,
         insert2: impl AsRef<str>,
     ) -> String {
         self.stock_str(id)
-            .await
             .replacen("%1$s", insert.as_ref(), 1)
             .replacen("%1$d", insert.as_ref(), 1)
             .replacen("%1$@", insert.as_ref(), 1)
@@ -300,7 +297,7 @@ impl Context {
     /// used as the second parameter to [StockMessage::MsgActionByUser] with
     /// again the original stock string being used as the first parameter,
     /// resulting in a string like "Member Alice added by Bob.".
-    pub async fn stock_system_msg(
+    pub fn stock_system_msg(
         &self,
         id: StockMessage,
         param1: impl AsRef<str>,
@@ -308,11 +305,9 @@ impl Context {
         from_id: u32,
     ) -> String {
         let insert1 = if id == StockMessage::MsgAddMember || id == StockMessage::MsgDelMember {
-            let contact_id =
-                Contact::lookup_id_by_addr(self, param1.as_ref(), Origin::Unknown).await;
+            let contact_id = Contact::lookup_id_by_addr(self, param1.as_ref(), Origin::Unknown);
             if contact_id != 0 {
                 Contact::get_by_id(self, contact_id)
-                    .await
                     .map(|contact| contact.get_name_n_addr())
                     .unwrap_or_default()
             } else {
@@ -322,60 +317,52 @@ impl Context {
             param1.as_ref().to_string()
         };
 
-        let action = self
-            .stock_string_repl_str2(id, insert1, param2.as_ref().to_string())
-            .await;
+        let action = self.stock_string_repl_str2(id, insert1, param2.as_ref().to_string());
         let action1 = action.trim_end_matches('.');
         match from_id {
             0 => action,
-            1 => {
-                self.stock_string_repl_str(StockMessage::MsgActionByMe, action1)
-                    .await
-            } // DC_CONTACT_ID_SELF
+            1 => self.stock_string_repl_str(StockMessage::MsgActionByMe, action1), // DC_CONTACT_ID_SELF
             _ => {
                 let displayname = Contact::get_by_id(self, from_id)
-                    .await
                     .map(|contact| contact.get_name_n_addr())
                     .unwrap_or_default();
 
                 self.stock_string_repl_str2(StockMessage::MsgActionByUser, action1, &displayname)
-                    .await
             }
         }
     }
 
-    pub async fn update_device_chats(&self) -> Result<(), Error> {
+    pub fn update_device_chats(&self) -> Result<(), Error> {
         // check for the LAST added device message - if it is present, we can skip message creation.
         // this is worthwhile as this function is typically called
         // by the ui on every probram start or even on every opening of the chatlist.
-        if chat::was_device_msg_ever_added(&self, "core-welcome").await? {
+        if chat::was_device_msg_ever_added(&self, "core-welcome")? {
             return Ok(());
         }
 
         // create saved-messages chat;
         // we do this only once, if the user has deleted the chat, he can recreate it manually.
-        if !self.sql.get_raw_config_bool(&self, "self-chat-added").await {
+        if !self.sql.get_raw_config_bool(&self, "self-chat-added") {
             self.sql
-                .set_raw_config_bool(&self, "self-chat-added", true)
-                .await?;
-            chat::create_by_contact_id(&self, DC_CONTACT_ID_SELF).await?;
+                .set_raw_config_bool(&self, "self-chat-added", true)?;
+            chat::create_by_contact_id(&self, DC_CONTACT_ID_SELF)?;
         }
 
         // add welcome-messages. by the label, this is done only once,
         // if the user has deleted the message or the chat, it is not added again.
         let mut msg = Message::new(Viewtype::Text);
-        msg.text = Some(self.stock_str(DeviceMessagesHint).await.to_string());
-        chat::add_device_msg(&self, Some("core-about-device-chat"), Some(&mut msg)).await?;
+        msg.text = Some(self.stock_str(DeviceMessagesHint).to_string());
+        chat::add_device_msg(&self, Some("core-about-device-chat"), Some(&mut msg))?;
 
         let image = include_bytes!("../assets/welcome-image.jpg");
-        let blob = BlobObject::create(&self, "welcome-image.jpg".to_string(), image).await?;
+        let blob = BlobObject::create(&self, "welcome-image.jpg".to_string(), image)?;
         let mut msg = Message::new(Viewtype::Image);
         msg.param.set(Param::File, blob.as_name());
-        chat::add_device_msg(&self, Some("core-welcome-image"), Some(&mut msg)).await?;
+        chat::add_device_msg(&self, Some("core-welcome-image"), Some(&mut msg))?;
 
         let mut msg = Message::new(Viewtype::Text);
-        msg.text = Some(self.stock_str(WelcomeMessage).await.to_string());
-        chat::add_device_msg(&self, Some("core-welcome"), Some(&mut msg)).await?;
+        msg.text = Some(self.stock_str(WelcomeMessage).to_string());
+        chat::add_device_msg(&self, Some("core-welcome"), Some(&mut msg))?;
         Ok(())
     }
 }
@@ -401,191 +388,165 @@ mod tests {
         assert_eq!(StockMessage::NoMessages.fallback(), "No messages.");
     }
 
-    #[async_std::test]
-    async fn test_set_stock_translation() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_set_stock_translation() {
+        let t = dummy_context();
         t.ctx
             .set_stock_translation(StockMessage::NoMessages, "xyz".to_string())
-            .await
             .unwrap();
-        assert_eq!(t.ctx.stock_str(StockMessage::NoMessages).await, "xyz")
+        assert_eq!(t.ctx.stock_str(StockMessage::NoMessages), "xyz")
     }
 
-    #[async_std::test]
-    async fn test_set_stock_translation_wrong_replacements() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_set_stock_translation_wrong_replacements() {
+        let t = dummy_context();
         assert!(t
             .ctx
             .set_stock_translation(StockMessage::NoMessages, "xyz %1$s ".to_string())
-            .await
             .is_err());
         assert!(t
             .ctx
             .set_stock_translation(StockMessage::NoMessages, "xyz %2$s ".to_string())
-            .await
             .is_err());
     }
 
-    #[async_std::test]
-    async fn test_stock_str() {
-        let t = dummy_context().await;
-        assert_eq!(
-            t.ctx.stock_str(StockMessage::NoMessages).await,
-            "No messages."
-        );
+    #[test]
+    fn test_stock_str() {
+        let t = dummy_context();
+        assert_eq!(t.ctx.stock_str(StockMessage::NoMessages), "No messages.");
     }
 
-    #[async_std::test]
-    async fn test_stock_string_repl_str() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_string_repl_str() {
+        let t = dummy_context();
         // uses %1$s substitution
         assert_eq!(
             t.ctx
-                .stock_string_repl_str(StockMessage::MsgAddMember, "Foo")
-                .await,
+                .stock_string_repl_str(StockMessage::MsgAddMember, "Foo"),
             "Member Foo added."
         );
         // We have no string using %1$d to test...
     }
 
-    #[async_std::test]
-    async fn test_stock_string_repl_int() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_string_repl_int() {
+        let t = dummy_context();
         assert_eq!(
-            t.ctx
-                .stock_string_repl_int(StockMessage::MsgAddMember, 42)
-                .await,
+            t.ctx.stock_string_repl_int(StockMessage::MsgAddMember, 42),
             "Member 42 added."
         );
     }
 
-    #[async_std::test]
-    async fn test_stock_string_repl_str2() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_string_repl_str2() {
+        let t = dummy_context();
         assert_eq!(
             t.ctx
-                .stock_string_repl_str2(StockMessage::ServerResponse, "foo", "bar")
-                .await,
+                .stock_string_repl_str2(StockMessage::ServerResponse, "foo", "bar"),
             "Could not connect to foo: bar"
         );
     }
 
-    #[async_std::test]
-    async fn test_stock_system_msg_simple() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_system_msg_simple() {
+        let t = dummy_context();
         assert_eq!(
             t.ctx
-                .stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0)
-                .await,
+                .stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0),
             "Location streaming enabled."
         )
     }
 
-    #[async_std::test]
-    async fn test_stock_system_msg_add_member_by_me() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_system_msg_add_member_by_me() {
+        let t = dummy_context();
         assert_eq!(
-            t.ctx
-                .stock_system_msg(
-                    StockMessage::MsgAddMember,
-                    "alice@example.com",
-                    "",
-                    DC_CONTACT_ID_SELF
-                )
-                .await,
+            t.ctx.stock_system_msg(
+                StockMessage::MsgAddMember,
+                "alice@example.com",
+                "",
+                DC_CONTACT_ID_SELF
+            ),
             "Member alice@example.com added by me."
         )
     }
 
-    #[async_std::test]
-    async fn test_stock_system_msg_add_member_by_me_with_displayname() {
-        let t = dummy_context().await;
-        Contact::create(&t.ctx, "Alice", "alice@example.com")
-            .await
-            .expect("failed to create contact");
+    #[test]
+    fn test_stock_system_msg_add_member_by_me_with_displayname() {
+        let t = dummy_context();
+        Contact::create(&t.ctx, "Alice", "alice@example.com").expect("failed to create contact");
         assert_eq!(
-            t.ctx
-                .stock_system_msg(
-                    StockMessage::MsgAddMember,
-                    "alice@example.com",
-                    "",
-                    DC_CONTACT_ID_SELF
-                )
-                .await,
+            t.ctx.stock_system_msg(
+                StockMessage::MsgAddMember,
+                "alice@example.com",
+                "",
+                DC_CONTACT_ID_SELF
+            ),
             "Member Alice (alice@example.com) added by me."
         );
     }
 
-    #[async_std::test]
-    async fn test_stock_system_msg_add_member_by_other_with_displayname() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_system_msg_add_member_by_other_with_displayname() {
+        let t = dummy_context();
         let contact_id = {
             Contact::create(&t.ctx, "Alice", "alice@example.com")
-                .await
                 .expect("Failed to create contact Alice");
-            Contact::create(&t.ctx, "Bob", "bob@example.com")
-                .await
-                .expect("failed to create bob")
+            Contact::create(&t.ctx, "Bob", "bob@example.com").expect("failed to create bob")
         };
         assert_eq!(
-            t.ctx
-                .stock_system_msg(
-                    StockMessage::MsgAddMember,
-                    "alice@example.com",
-                    "",
-                    contact_id,
-                )
-                .await,
+            t.ctx.stock_system_msg(
+                StockMessage::MsgAddMember,
+                "alice@example.com",
+                "",
+                contact_id,
+            ),
             "Member Alice (alice@example.com) added by Bob (bob@example.com)."
         );
     }
 
-    #[async_std::test]
-    async fn test_stock_system_msg_grp_name() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_system_msg_grp_name() {
+        let t = dummy_context();
         assert_eq!(
-            t.ctx
-                .stock_system_msg(
-                    StockMessage::MsgGrpName,
-                    "Some chat",
-                    "Other chat",
-                    DC_CONTACT_ID_SELF
-                )
-                .await,
+            t.ctx.stock_system_msg(
+                StockMessage::MsgGrpName,
+                "Some chat",
+                "Other chat",
+                DC_CONTACT_ID_SELF
+            ),
             "Group name changed from \"Some chat\" to \"Other chat\" by me."
         )
     }
 
-    #[async_std::test]
-    async fn test_stock_system_msg_grp_name_other() {
-        let t = dummy_context().await;
+    #[test]
+    fn test_stock_system_msg_grp_name_other() {
+        let t = dummy_context();
         let id = Contact::create(&t.ctx, "Alice", "alice@example.com")
-            .await
             .expect("failed to create contact");
 
         assert_eq!(
             t.ctx
-                .stock_system_msg(StockMessage::MsgGrpName, "Some chat", "Other chat", id)
-                .await,
+                .stock_system_msg(StockMessage::MsgGrpName, "Some chat", "Other chat", id,),
             "Group name changed from \"Some chat\" to \"Other chat\" by Alice (alice@example.com)."
         )
     }
 
-    #[async_std::test]
-    async fn test_update_device_chats() {
-        let t = dummy_context().await;
-        t.ctx.update_device_chats().await.ok();
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
+    #[test]
+    fn test_update_device_chats() {
+        let t = dummy_context();
+        t.ctx.update_device_chats().ok();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
         assert_eq!(chats.len(), 2);
 
-        chats.get_chat_id(0).delete(&t.ctx).await.ok();
-        chats.get_chat_id(1).delete(&t.ctx).await.ok();
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
+        chats.get_chat_id(0).delete(&t.ctx).ok();
+        chats.get_chat_id(1).delete(&t.ctx).ok();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
         assert_eq!(chats.len(), 0);
 
         // a subsequent call to update_device_chats() must not re-add manally deleted messages or chats
-        t.ctx.update_device_chats().await.ok();
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
+        t.ctx.update_device_chats().ok();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
         assert_eq!(chats.len(), 0);
     }
 }

src/test_utils.rs

@@ -5,8 +5,9 @@
 use tempfile::{tempdir, TempDir};
 
 use crate::config::Config;
-use crate::context::Context;
+use crate::context::{Context, ContextCallback};
 use crate::dc_tools::EmailAddress;
+use crate::events::Event;
 use crate::key::{self, DcKey};
 
 /// A Context and temporary directory.
@@ -24,10 +25,14 @@ pub(crate) struct TestContext {
 /// "db.sqlite" in the [TestContext.dir] directory.
 ///
 /// [Context]: crate::context::Context
-pub(crate) async fn test_context() -> TestContext {
+pub(crate) fn test_context(callback: Option<Box<ContextCallback>>) -> TestContext {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
-    let ctx = Context::new("FakeOs".into(), dbfile.into()).await.unwrap();
+    let cb: Box<ContextCallback> = match callback {
+        Some(cb) => cb,
+        None => Box::new(|_, _| ()),
+    };
+    let ctx = Context::new(cb, "FakeOs".into(), dbfile).unwrap();
     TestContext { ctx, dir }
 }
 
@@ -36,8 +41,17 @@ pub(crate) async fn test_context() -> TestContext {
 /// The context will be opened and use the SQLite database as
 /// specified in [test_context] but there is no callback hooked up,
 /// i.e. [Context::call_cb] will always return `0`.
-pub(crate) async fn dummy_context() -> TestContext {
-    test_context().await
+pub(crate) fn dummy_context() -> TestContext {
+    test_context(Some(Box::new(logging_cb)))
+}
+
+pub(crate) fn logging_cb(_ctx: &Context, evt: Event) {
+    match evt {
+        Event::Info(msg) => println!("I: {}", msg),
+        Event::Warning(msg) => eprintln!("=== WARNING ===\n{}\n===============", msg),
+        Event::Error(msg) => eprintln!("\n===================== ERROR =====================\n{}\n=================================================\n", msg),
+        _ => (),
+    }
 }
 
 /// Load a pre-generated keypair for alice@example.com from disk.
@@ -63,13 +77,11 @@ pub(crate) fn alice_keypair() -> key::KeyPair {
 /// Creates Alice with a pre-generated keypair.
 ///
 /// Returns the address of the keypair created (alice@example.com).
-pub(crate) async fn configure_alice_keypair(ctx: &Context) -> String {
+pub(crate) fn configure_alice_keypair(ctx: &Context) -> String {
     let keypair = alice_keypair();
     ctx.set_config(Config::ConfiguredAddr, Some(&keypair.addr.to_string()))
-        .await
         .unwrap();
     key::store_self_keypair(&ctx, &keypair, key::KeyPairUse::Default)
-        .await
         .expect("Failed to save Alice's key");
     keypair.addr.to_string()
 }

src/token.rs

@@ -9,6 +9,7 @@ use deltachat_derive::*;
 use crate::chat::ChatId;
 use crate::context::Context;
 use crate::dc_tools::*;
+use crate::sql;
 
 /// Token namespace
 #[derive(Debug, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, ToSql, FromSql)]
@@ -27,46 +28,37 @@ impl Default for Namespace {
 
 /// Creates a new token and saves it into the database.
 /// Returns created token.
-pub async fn save(context: &Context, namespace: Namespace, foreign_id: ChatId) -> String {
+pub fn save(context: &Context, namespace: Namespace, foreign_id: ChatId) -> String {
     // foreign_id may be 0
     let token = dc_create_id();
-    context
-        .sql
-        .execute(
-            "INSERT INTO tokens (namespc, foreign_id, token, timestamp) VALUES (?, ?, ?, ?);",
-            paramsv![namespace, foreign_id, token, time()],
-        )
-        .await
-        .ok();
+    sql::execute(
+        context,
+        &context.sql,
+        "INSERT INTO tokens (namespc, foreign_id, token, timestamp) VALUES (?, ?, ?, ?);",
+        params![namespace, foreign_id, &token, time()],
+    )
+    .ok();
     token
 }
 
-pub async fn lookup(context: &Context, namespace: Namespace, foreign_id: ChatId) -> Option<String> {
-    context
-        .sql
-        .query_get_value::<String>(
-            context,
-            "SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;",
-            paramsv![namespace, foreign_id],
-        )
-        .await
+pub fn lookup(context: &Context, namespace: Namespace, foreign_id: ChatId) -> Option<String> {
+    context.sql.query_get_value::<_, String>(
+        context,
+        "SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;",
+        params![namespace, foreign_id],
+    )
 }
 
-pub async fn lookup_or_new(context: &Context, namespace: Namespace, foreign_id: ChatId) -> String {
-    if let Some(token) = lookup(context, namespace, foreign_id).await {
-        return token;
-    }
-
-    save(context, namespace, foreign_id).await
+pub fn lookup_or_new(context: &Context, namespace: Namespace, foreign_id: ChatId) -> String {
+    lookup(context, namespace, foreign_id).unwrap_or_else(|| save(context, namespace, foreign_id))
 }
 
-pub async fn exists(context: &Context, namespace: Namespace, token: &str) -> bool {
+pub fn exists(context: &Context, namespace: Namespace, token: &str) -> bool {
     context
         .sql
         .exists(
             "SELECT id FROM tokens WHERE namespc=? AND token=?;",
-            paramsv![namespace, token],
+            params![namespace, token],
         )
-        .await
         .unwrap_or_default()
 }

standards.md

@@ -1,19 +0,0 @@
-# Standards used in Delta Chat
-
-Some of the standards Delta Chat is based on:
-
-Tasks                            | Standards
----------------------------------|---------------------------------------------
-Transport                        | IMAP v4 ([RFC 3501](https://tools.ietf.org/html/rfc3501)), SMTP ([RFC 5321](https://tools.ietf.org/html/rfc5321)) and Internet Message Format (IMF, [RFC 5322](https://tools.ietf.org/html/rfc5322))
-Embedded media                   | MIME Document Series ([RFC 2045](https://tools.ietf.org/html/rfc2045), [RFC 2046](https://tools.ietf.org/html/rfc2046)), Content-Disposition Header ([RFC 2183](https://tools.ietf.org/html/rfc2183)), Multipart/Related ([RFC 2387](https://tools.ietf.org/html/rfc2387))
-Identify server folders          | IMAP LIST Extension ([RFC 6154](https://tools.ietf.org/html/rfc6154))
-Push                             | IMAP IDLE ([RFC 2177](https://tools.ietf.org/html/rfc2177))
-Authorization                    | OAuth2 ([RFC 6749](https://tools.ietf.org/html/rfc6749))
-End-to-end encryption            | [Autocrypt Level 1](https://autocrypt.org/level1.html), OpenPGP ([RFC 4880](https://tools.ietf.org/html/rfc4880)) and Security Multiparts for MIME ([RFC 1847](https://tools.ietf.org/html/rfc1847))
-Configuration assistance         | [Autoconfigure](https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration) and [Autodiscover](https://technet.microsoft.com/library/bb124251(v=exchg.150).aspx)
-Messenger functions              | [Chat-over-Email](https://github.com/deltachat/deltachat-core-rust/blob/master/spec.md#chat-over-email-specification)
-Detect mailing list              | List-Id ([RFC 2919](https://tools.ietf.org/html/rfc2919)) and Precedence ([RFC 3834](https://tools.ietf.org/html/rfc3834))
-Send and receive system messages | Multipart/Report Media Type ([RFC 6522](https://tools.ietf.org/html/rfc6522))
-Return receipts                  | Message Disposition Notification (MDN, [RFC 8098](https://tools.ietf.org/html/rfc8098), [RFC 3503](https://tools.ietf.org/html/rfc3503)) using the Chat-Disposition-Notification-To header
-Locations                        | KML ([Open Geospatial Consortium](http://www.opengeospatial.org/standards/kml/), [Google Dev](https://developers.google.com/kml/))
-

tests/stress.rs

@@ -2,16 +2,14 @@
 
 use deltachat::config;
 use deltachat::context::*;
+use deltachat::Event;
 use tempfile::{tempdir, TempDir};
 
 /* some data used for testing
  ******************************************************************************/
 
-async fn stress_functions(context: &Context) {
-    let res = context
-        .get_config(config::Config::SysConfigKeys)
-        .await
-        .unwrap();
+fn stress_functions(context: &Context) {
+    let res = context.get_config(config::Config::SysConfigKeys).unwrap();
 
     assert!(!res.contains(" probably_never_a_key "));
     assert!(res.contains(" addr "));
@@ -92,21 +90,23 @@ async fn stress_functions(context: &Context) {
     // free(qr.cast());
 }
 
+fn cb(_context: &Context, _event: Event) {}
+
 #[allow(dead_code)]
 struct TestContext {
     ctx: Context,
     dir: TempDir,
 }
 
-async fn create_test_context() -> TestContext {
+fn create_test_context() -> TestContext {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
-    let ctx = Context::new("FakeOs".into(), dbfile.into()).await.unwrap();
+    let ctx = Context::new(Box::new(cb), "FakeOs".into(), dbfile).unwrap();
     TestContext { ctx, dir }
 }
 
-#[async_std::test]
-async fn test_stress_tests() {
-    let context = create_test_context().await;
-    stress_functions(&context.ctx).await;
+#[test]
+fn test_stress_tests() {
+    let context = create_test_context();
+    stress_functions(&context.ctx);
 }