intermediate commit

some more cleanups but not quite working yet
first round of configure cleanups
2026-04-06 23:52:11 +03:00 · 2019-10-06 01:28:17 +02:00 · 2019-10-06 01:03:13 +02:00 · 2019-10-06 01:00:11 +02:00
37 changed files with 1289 additions and 1352 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -4,9 +4,6 @@ executors:
    docker:
      - image: filecoin/rust:latest
    working_directory: /mnt/crate
-  doxygen:
-    docker:
-      - image: hrektts/doxygen

 restore-workspace: &restore-workspace
  attach_workspace:
@@ -116,18 +113,6 @@ jobs:
          target: "aarch64-linux-android"


-  build_doxygen:
-    executor: doxygen
-    steps:
-      - checkout
-      - run: bash ci_scripts/run-doxygen.sh
-      - run: mkdir -p workspace/c-docs 
-      - run: cp -av deltachat-ffi/{html,xml} workspace/c-docs/
-      - persist_to_workspace:
-          root: workspace
-          paths:
-            - c-docs
-
  build_test_docs_wheel:
    docker:
      - image: deltachat/coredeps
@@ -163,7 +148,7 @@ jobs:
          at: workspace
      - run: pyenv global 3.5.2
      - run: ls -laR workspace
-      - run: ci_scripts/ci_upload.sh workspace/py-docs workspace/wheelhouse workspace/c-docs
+      - run: ci_scripts/ci_upload.sh workspace/py-docs workspace/wheelhouse

  clippy:
    executor: default
@@ -181,21 +166,18 @@ workflows:
  test:
    jobs:
      - cargo_fetch
-      - build_doxygen
-
      - build_test_docs_wheel:
          requires:
            - cargo_fetch
      - upload_docs_wheels:
          requires:
            - build_test_docs_wheel
-            - build_doxygen 
      - rustfmt:
          requires:
            - cargo_fetch
      - clippy:
          requires:
-           - cargo_fetch
+            - cargo_fetch

      # Linux Desktop 64bit
      - test_x86_64-unknown-linux-gnu:
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -500,7 +500,7 @@ dependencies = [
 "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "jetscii 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "lettre 0.9.2 (git+https://github.com/deltachat/lettre)",
+ "lettre 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
 "mmime 0.1.2",
 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1072,7 +1072,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "lettre"
 version = "0.9.2"
-source = "git+https://github.com/deltachat/lettre#aeec999c27a70870e4b7b149e45f24188c1ff351"
+source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bufstream 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1080,7 +1080,7 @@ dependencies = [
 "hostname 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "nom 5.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "nom 4.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.101 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.101 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2968,7 +2968,7 @@ dependencies = [
 "checksum keccak 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
 "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
 "checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-"checksum lettre 0.9.2 (git+https://github.com/deltachat/lettre)" = "<none>"
+"checksum lettre 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c66afaa5dfadbb81d4e00fd1d1ab057c7cd4c799c5a44e0009386d553587e728"
 "checksum lexical-core 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2304bccb228c4b020f3a4835d247df0a02a7c4686098d4167762cfbbe4c5cb14"
 "checksum libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)" = "34fcd2c08d2f832f376f4173a231990fa5aef4e99fb569867318a227ef4c06ba"
 "checksum libsqlite3-sys 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5b95e89c330291768dc840238db7f9e204fd208511ab6319b56193a7f2ae25"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,7 +19,7 @@ reqwest = "0.9.15"
 num-derive = "0.2.5"
 num-traits = "0.2.6"
 native-tls = "0.2.3"
-lettre = { git = "https://github.com/deltachat/lettre" }
+lettre = "0.9.0"
 imap = { git = "https://github.com/jonhoo/rust-imap", rev = "281d2eb8ab50dc656ceff2ae749ca5045f334e15" }
 base64 = "0.10"
 charset = "0.1"
--- a/ci_scripts/ci_upload.sh
+++ b/ci_scripts/ci_upload.sh
@@ -7,9 +7,9 @@ fi

 set -xe

+#DOXYDOCDIR=${1:?directory where doxygen docs to be found}
 PYDOCDIR=${1:?directory with python docs}
 WHEELHOUSEDIR=${2:?directory with pre-built wheels}
-DOXYDOCDIR=${3:?directory where doxygen docs to be found}

 export BRANCH=${CIRCLE_BRANCH:?specify branch for uploading purposes}

@@ -22,10 +22,10 @@ rsync -avz \
  delta@py.delta.chat:build/${BRANCH}

 # C docs to c.delta.chat
-rsync -avz \
-  -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
-  "$DOXYDOCDIR/html/" \
-  delta@c.delta.chat:build-c/${BRANCH}
+#rsync -avz \
+#  -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
+#  "$DOXYDOCDIR/html/" \
+#  delta@py.delta.chat:build-c/${BRANCH}

 echo -----------------------
 echo upload wheels 
--- a/ci_scripts/run-doxygen.sh
+++ b/ci_scripts/run-doxygen.sh
@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-cd deltachat-ffi 
-doxygen 
-
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -402,18 +402,6 @@ int             dc_set_config                (dc_context_t* context, const char*
 */
 char*           dc_get_config                (dc_context_t* context, const char* key);

-/**
- * Set stock string translation. 
- *
- * The function will emit warnings if it returns an error state. 
- *
- * @param context The context object
- * @param stock_id   the integer id of the stock message (DC_STR_*)
- * @param stock_msg  the message to be used 
- * @return int (==0 on error, 1 on success)
- */
-int             dc_set_stock_translation(dc_context_t* context, uint32_t, const char* value);
-

 /**
 * Get information about the context.
@@ -4201,10 +4189,16 @@ int64_t          dc_lot_get_timestamp     (const dc_lot_t* lot);


 /**
- * (DEPRECATED, DC_EVENT_GET_STRING is not emmitted anymore.  Use
- * dc_set_stock_translation() to pre-fill translations for stock
- * messages. 
+ * Requeste a localized string from the frontend.
 *
+ * @param data1 (int) ID of the string to request, one of the DC_STR_* constants.
+ * @param data2 (int) The count. If the requested string contains a placeholder for a numeric value,
+ *     the ui may use this value to return different strings on different plural forms.
+ * @return (const char*) Null-terminated UTF-8 string.
+ *     The string will be free()'d by the core,
+ *     so it must be allocated using malloc() or a compatible function.
+ *     Return 0 if the ui cannot provide the requested string
+ *     the core will use a default string in english language then.
 */
 #define DC_EVENT_GET_STRING               2091

@@ -4322,8 +4316,7 @@ void            dc_array_add_id              (dc_array_t*, uint32_t); // depreca
 #define DC_STR_MSGLOCATIONENABLED         64
 #define DC_STR_MSGLOCATIONDISABLED        65
 #define DC_STR_LOCATION                   66
-#define DC_STR_STICKER                    67
-#define DC_STR_COUNT                      67
+#define DC_STR_COUNT                      66

 void dc_str_unref (char*);

--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -25,7 +25,6 @@ use num_traits::{FromPrimitive, ToPrimitive};
 use deltachat::contact::Contact;
 use deltachat::context::Context;
 use deltachat::dc_tools::{as_path, as_str, dc_strdup, to_string_lossy, OsStrExt, StrExt};
-use deltachat::stock::StockMessage;
 use deltachat::*;

 // as C lacks a good and portable error handling,
@@ -167,6 +166,12 @@ impl ContextWrapper {
                        contact_id as uintptr_t,
                        progress as uintptr_t,
                    ),
+                    Event::GetString { id, count } => ffi_cb(
+                        self,
+                        event_id,
+                        id.to_u32().unwrap_or_default() as uintptr_t,
+                        count as uintptr_t,
+                    ),
                }
            }
            None => 0,
@@ -337,35 +342,6 @@ pub unsafe extern "C" fn dc_get_config(
    }
 }

-#[no_mangle]
-pub unsafe extern "C" fn dc_set_stock_translation(
-    context: *mut dc_context_t,
-    stock_id: u32,
-    stock_msg: *mut libc::c_char,
-) -> libc::c_int {
-    if context.is_null() || stock_msg.is_null() {
-        eprintln!("ignoring careless call to dc_set_stock_string");
-        return 0;
-    }
-    let msg = as_str(stock_msg).to_string();
-    let ffi_context = &*context;
-    ffi_context
-        .with_inner(|ctx| match StockMessage::from_u32(stock_id) {
-            Some(id) => match ctx.set_stock_translation(id, msg) {
-                Ok(()) => 1,
-                Err(err) => {
-                    warn!(ctx, "set_stock_translation failed: {}", err);
-                    0
-                }
-            },
-            None => {
-                warn!(ctx, "invalid stock message id {}", stock_id);
-                0
-            }
-        })
-        .unwrap_or(0)
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_info(context: *mut dc_context_t) -> *mut libc::c_char {
    if context.is_null() {
@@ -1644,7 +1620,9 @@ pub unsafe extern "C" fn dc_stop_ongoing_process(context: *mut dc_context_t) {
        return;
    }
    let ffi_context = &*context;
-    ffi_context.with_inner(|ctx| ctx.stop_ongoing()).ok();
+    ffi_context
+        .with_inner(|ctx| configure::dc_stop_ongoing_process(ctx))
+        .ok();
 }

 #[no_mangle]
@@ -2158,7 +2136,7 @@ pub unsafe extern "C" fn dc_chat_get_profile_image(chat: *mut dc_chat_t) -> *mut
    let ffi_context = &*ffi_chat.context;
    ffi_context
        .with_inner(|ctx| match ffi_chat.chat.get_profile_image(ctx) {
-            Some(p) => p.to_string_lossy().strdup(),
+            Some(p) => p.to_str().unwrap_or_default().to_string().strdup(),
            None => ptr::null_mut(),
        })
        .unwrap_or_else(|_| ptr::null_mut())
@@ -2795,7 +2773,7 @@ pub unsafe extern "C" fn dc_contact_get_profile_image(
            ffi_contact
                .contact
                .get_profile_image(ctx)
-                .map(|p| p.to_string_lossy().strdup())
+                .map(|p| p.to_str().unwrap_or_default().to_string().strdup())
                .unwrap_or_else(|| std::ptr::null_mut())
        })
        .unwrap_or_else(|_| ptr::null_mut())
--- a/examples/repl/cmdline.rs
+++ b/examples/repl/cmdline.rs
@@ -4,6 +4,7 @@ use std::str::FromStr;
 use deltachat::chat::{self, Chat};
 use deltachat::chatlist::*;
 use deltachat::config;
+use deltachat::configure::*;
 use deltachat::constants::*;
 use deltachat::contact::*;
 use deltachat::context::*;
@@ -470,7 +471,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
            ensure!(0 != dc_reset_tables(context, bits), "Reset failed");
        }
        "stop" => {
-            context.stop_ongoing();
+            dc_stop_ongoing_process(context);
        }
        "set" => {
            ensure!(!arg1.is_empty(), "Argument <key> missing.");
--- a/examples/repl/main.rs
+++ b/examples/repl/main.rs
@@ -43,6 +43,7 @@ use self::cmdline::*;

 fn receive_event(_context: &Context, event: Event) -> libc::uintptr_t {
    match event {
+        Event::GetString { .. } => {}
        Event::Info(msg) => {
            /* do not show the event as this would fill the screen */
            println!("{}", msg);
--- a/examples/simple.rs
+++ b/examples/simple.rs
@@ -35,90 +35,93 @@ fn cb(_ctx: &Context, event: Event) -> usize {
 }

 fn main() {
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    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 ctx = Arc::new(ctx);
-    let ctx1 = ctx.clone();
-    let r1 = running.clone();
-    let t1 = thread::spawn(move || {
-        while *r1.read().unwrap() {
-            perform_imap_jobs(&ctx1);
-            if *r1.read().unwrap() {
-                perform_imap_fetch(&ctx1);
+    unsafe {
+        let dir = tempdir().unwrap();
+        let dbfile = dir.path().join("db.sqlite");
+        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 ctx = Arc::new(ctx);
+        let ctx1 = ctx.clone();
+        let r1 = running.clone();
+        let t1 = thread::spawn(move || {
+            while *r1.read().unwrap() {
+                perform_imap_jobs(&ctx1);
                if *r1.read().unwrap() {
-                    perform_imap_idle(&ctx1);
+                    perform_imap_fetch(&ctx1);
+
+                    if *r1.read().unwrap() {
+                        perform_imap_idle(&ctx1);
+                    }
                }
            }
-        }
-    });
+        });

-    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);
+        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(), 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();
+        configure(&ctx);
+
+        thread::sleep(duration);
+
+        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();
+
+        println!("fetching chats..");
+        let chats = Chatlist::try_load(&ctx, 0, None, None).unwrap();
+
+        for i in 0..chats.len() {
+            let summary = chats.get_summary(&ctx, 0, None);
+            let text1 = summary.get_text1();
+            let text2 = summary.get_text2();
+            println!("chat: {} - {:?} - {:?}", i, text1, text2,);
        }
-    });

-    println!("configuring");
-    let args = std::env::args().collect::<Vec<String>>();
-    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();
-    configure(&ctx);
+        thread::sleep(duration);

-    thread::sleep(duration);
+        // let msglist = dc_get_chat_msgs(&ctx, chat_id, 0, 0);
+        // for i in 0..dc_array_get_cnt(msglist) {
+        //     let msg_id = dc_array_get_id(msglist, i);
+        //     let msg = dc_get_msg(context, msg_id);
+        //     let text = CStr::from_ptr(dc_msg_get_text(msg)).unwrap();
+        //     println!("Message {}: {}\n", i + 1, text.to_str().unwrap());
+        //     dc_msg_unref(msg);
+        // }
+        // dc_array_unref(msglist);

-    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();
+        println!("stopping threads");

-    println!("fetching chats..");
-    let chats = Chatlist::try_load(&ctx, 0, None, None).unwrap();
+        *running.clone().write().unwrap() = false;
+        deltachat::job::interrupt_imap_idle(&ctx);
+        deltachat::job::interrupt_smtp_idle(&ctx);

-    for i in 0..chats.len() {
-        let summary = chats.get_summary(&ctx, 0, None);
-        let text1 = summary.get_text1();
-        let text2 = summary.get_text2();
-        println!("chat: {} - {:?} - {:?}", i, text1, text2,);
+        println!("joining");
+        t1.join().unwrap();
+        t2.join().unwrap();
+
+        println!("closing");
    }
-
-    thread::sleep(duration);
-
-    // let msglist = dc_get_chat_msgs(&ctx, chat_id, 0, 0);
-    // for i in 0..dc_array_get_cnt(msglist) {
-    //     let msg_id = dc_array_get_id(msglist, i);
-    //     let msg = dc_get_msg(context, msg_id);
-    //     let text = CStr::from_ptr(dc_msg_get_text(msg)).unwrap();
-    //     println!("Message {}: {}\n", i + 1, text.to_str().unwrap());
-    //     dc_msg_unref(msg);
-    // }
-    // dc_array_unref(msglist);
-
-    println!("stopping threads");
-
-    *running.clone().write().unwrap() = false;
-    deltachat::job::interrupt_imap_idle(&ctx);
-    deltachat::job::interrupt_smtp_idle(&ctx);
-
-    println!("joining");
-    t1.join().unwrap();
-    t2.join().unwrap();
-
-    println!("closing");
 }
--- a/mmime/src/charconv.rs
+++ b/mmime/src/charconv.rs
@@ -16,9 +16,12 @@ pub unsafe fn charconv(
 ) -> libc::c_int {
    assert!(!fromcode.is_null(), "invalid fromcode");
    assert!(!s.is_null(), "invalid input string");
-    if let Some(encoding) =
-        charset::Charset::for_label(CStr::from_ptr(fromcode).to_string_lossy().as_bytes())
-    {
+    if let Some(encoding) = charset::Charset::for_label(
+        CStr::from_ptr(fromcode)
+            .to_str()
+            .unwrap_or_default()
+            .as_bytes(),
+    ) {
        let data = std::slice::from_raw_parts(s as *const u8, strlen(s));

        let (res, _, _) = encoding.decode(data);
--- a/mmime/src/mailmime/write_generic.rs
+++ b/mmime/src/mailmime/write_generic.rs
@@ -1515,8 +1515,8 @@ pub unsafe fn mailmime_data_write_driver(
        }
        1 => {
            let filename = CStr::from_ptr((*mime_data).dt_data.dt_filename)
-                .to_string_lossy()
-                .into_owned();
+                .to_str()
+                .unwrap_or_default();
            if let Ok(file) = std::fs::File::open(filename) {
                if let Ok(mut text) = memmap::MmapOptions::new().map_copy(&file) {
                    if 0 != (*mime_data).dt_encoded {
--- a/python/doc/_templates/globaltoc.html
+++ b/python/doc/_templates/globaltoc.html
@@ -6,6 +6,7 @@
  <li><a href="{{ pathto('install') }}">install</a></li>
  <li><a href="{{ pathto('api') }}">high level API</a></li>
  <li><a href="{{ pathto('lapi') }}">low level API</a></li>
+  <li><a href="{{ pathto('capi') }}">C deltachat.h</a></li>
 </ul>
 <b>external links:</b>
 <ul>
--- a/python/doc/lapi.rst
+++ b/python/doc/lapi.rst
@@ -2,13 +2,7 @@
 low level API reference
 ===================================

-for full doxygen-generated C-docs, defines and functions please checkout
-
-https://c.delta.chat
-
-
-Python low-level capi calls
---------------------------
+for full C-docs, defines and function checkout :doc:`capi`


 .. automodule:: deltachat.capi.lib
--- a/python/src/deltachat/account.py
+++ b/python/src/deltachat/account.py
@@ -1,7 +1,6 @@
 """ Account class implementation. """

 from __future__ import print_function
-import atexit
 import threading
 import re
 import time
@@ -50,10 +49,9 @@ class Account(object):
            raise ValueError("Could not dc_open: {}".format(db_path))
        self._configkeys = self.get_config("sys.config_keys").split()
        self._imex_events = Queue()
-        atexit.register(self.shutdown)

-    # def __del__(self):
-    #    self.shutdown()
+    def __del__(self):
+        self.shutdown()

    def _check_config_key(self, name):
        if name not in self._configkeys:
@@ -71,18 +69,6 @@ class Account(object):
            d[key.lower()] = value
        return d

-    def set_stock_translation(self, id, string):
-        """ set stock translation string.
-
-        :param id: id of stock string (const.DC_STR_*)
-        :param value: string to set as new transalation
-        :returns: None
-        """
-        string = string.encode("utf8")
-        res = lib.dc_set_stock_translation(self._dc_context, id, string)
-        if res == 0:
-            raise ValueError("could not set translation string")
-
    def set_config(self, name, value):
        """ set configuration values.

@@ -425,9 +411,6 @@ class Account(object):
            raise ValueError("could not join group")
        return Chat(self, chat_id)

-    def stop_ongoing(self):
-        lib.dc_stop_ongoing_process(self._dc_context)
-
    #
    # meta API for start/stop and event based processing
    #
@@ -449,7 +432,7 @@ class Account(object):

    def stop_threads(self, wait=True):
        """ stop IMAP/SMTP threads. """
-        self.stop_ongoing()
+        lib.dc_stop_ongoing_process(self._dc_context)
        self._threads.stop(wait=wait)

    def shutdown(self, wait=True):
@@ -461,7 +444,6 @@ class Account(object):
            self.stop_threads(wait=wait)  # to wait for threads
            deltachat.clear_context_callback(self._dc_context)
            del self._dc_context
-            atexit.unregister(self.shutdown)

    def _process_event(self, ctx, evt_name, data1, data2):
        assert ctx == self._dc_context
--- a/python/src/deltachat/const.py
+++ b/python/src/deltachat/const.py
@@ -85,61 +85,14 @@ DC_EVENT_SECUREJOIN_JOINER_PROGRESS = 2061
 DC_EVENT_GET_STRING = 2091
 DC_EVENT_FILE_COPIED = 2055
 DC_EVENT_IS_OFFLINE = 2081
-DC_STR_SELFNOTINGRP = 21
 DC_PROVIDER_STATUS_OK = 1
 DC_PROVIDER_STATUS_PREPARATION = 2
 DC_PROVIDER_STATUS_BROKEN = 3
-DC_STR_NOMESSAGES = 1
-DC_STR_SELF = 2
-DC_STR_DRAFT = 3
-DC_STR_MEMBER = 4
-DC_STR_CONTACT = 6
-DC_STR_VOICEMESSAGE = 7
-DC_STR_DEADDROP = 8
-DC_STR_IMAGE = 9
-DC_STR_VIDEO = 10
-DC_STR_AUDIO = 11
-DC_STR_FILE = 12
-DC_STR_STATUSLINE = 13
-DC_STR_NEWGROUPDRAFT = 14
-DC_STR_MSGGRPNAME = 15
-DC_STR_MSGGRPIMGCHANGED = 16
-DC_STR_MSGADDMEMBER = 17
-DC_STR_MSGDELMEMBER = 18
-DC_STR_MSGGROUPLEFT = 19
-DC_STR_GIF = 23
-DC_STR_ENCRYPTEDMSG = 24
-DC_STR_E2E_AVAILABLE = 25
-DC_STR_ENCR_TRANSP = 27
-DC_STR_ENCR_NONE = 28
-DC_STR_CANTDECRYPT_MSG_BODY = 29
-DC_STR_FINGERPRINTS = 30
-DC_STR_READRCPT = 31
-DC_STR_READRCPT_MAILBODY = 32
-DC_STR_MSGGRPIMGDELETED = 33
-DC_STR_E2E_PREFERRED = 34
-DC_STR_CONTACT_VERIFIED = 35
-DC_STR_CONTACT_NOT_VERIFIED = 36
-DC_STR_CONTACT_SETUP_CHANGED = 37
-DC_STR_ARCHIVEDCHATS = 40
-DC_STR_STARREDMSGS = 41
-DC_STR_AC_SETUP_MSG_SUBJECT = 42
-DC_STR_AC_SETUP_MSG_BODY = 43
-DC_STR_SELFTALK_SUBTITLE = 50
-DC_STR_CANNOT_LOGIN = 60
-DC_STR_SERVER_RESPONSE = 61
-DC_STR_MSGACTIONBYUSER = 62
-DC_STR_MSGACTIONBYME = 63
-DC_STR_MSGLOCATIONENABLED = 64
-DC_STR_MSGLOCATIONDISABLED = 65
-DC_STR_LOCATION = 66
-DC_STR_STICKER = 67
-DC_STR_COUNT = 67
 # end const generated


 def read_event_defines(f):
-    rex = re.compile(r'#define\s+((?:DC_EVENT_|DC_QR|DC_MSG|DC_STATE_|DC_STR|'
+    rex = re.compile(r'#define\s+((?:DC_EVENT_|DC_QR|DC_MSG|DC_STATE_|'
                     r'DC_CONTACT_ID_|DC_GCL|DC_CHAT|DC_PROVIDER)\S+)\s+([x\d]+).*')
    for line in f:
        m = rex.match(line)
--- a/python/tests/test_account.py
+++ b/python/tests/test_account.py
@@ -148,27 +148,6 @@ class TestOfflineChat:
        chat.set_name("title2")
        assert chat.get_name() == "title2"

-    def test_group_chat_creation_with_translation(self, ac1):
-        ac1.set_stock_translation(const.DC_STR_NEWGROUPDRAFT, "xyz %1$s")
-        ac1._evlogger.consume_events()
-        with pytest.raises(ValueError):
-            ac1.set_stock_translation(const.DC_STR_NEWGROUPDRAFT, "xyz %2$s")
-        ac1._evlogger.get_matching("DC_EVENT_WARNING")
-        with pytest.raises(ValueError):
-            ac1.set_stock_translation(500, "xyz %1$s")
-        ac1._evlogger.get_matching("DC_EVENT_WARNING")
-        contact1 = ac1.create_contact("some1@hello.com", name="some1")
-        contact2 = ac1.create_contact("some2@hello.com", name="some2")
-        chat = ac1.create_group_chat(name="title1")
-        chat.add_contact(contact1)
-        chat.add_contact(contact2)
-        assert chat.get_name() == "title1"
-        assert contact1 in chat.get_contacts()
-        assert contact2 in chat.get_contacts()
-        assert not chat.is_promoted()
-        msg = chat.get_draft()
-        assert msg.text == "xyz title1"
-
    @pytest.mark.parametrize("verified", [True, False])
    def test_group_chat_qr(self, acfactory, ac1, verified):
        ac2 = acfactory.get_configured_offline_account()
@@ -371,12 +350,6 @@ class TestOnlineAccount:
        assert chat.id > const.DC_CHAT_ID_LAST_SPECIAL
        return chat

-    def test_configure_canceled(self, acfactory):
-        ac1 = acfactory.get_online_configuring_account()
-        wait_configuration_progress(ac1, 200)
-        ac1.stop_ongoing()
-        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")
--- a/src/aheader.rs
+++ b/src/aheader.rs
@@ -79,13 +79,19 @@ impl Aheader {
                let optional_field = unsafe { (*field).fld_data.fld_optional_field };
                if !optional_field.is_null()
                    && unsafe { !(*optional_field).fld_name.is_null() }
-                    && unsafe { CStr::from_ptr((*optional_field).fld_name).to_string_lossy() }
-                        == "Autocrypt"
+                    && unsafe {
+                        CStr::from_ptr((*optional_field).fld_name)
+                            .to_str()
+                            .unwrap_or_default()
+                    } == "Autocrypt"
                {
-                    let value =
-                        unsafe { CStr::from_ptr((*optional_field).fld_value).to_string_lossy() };
+                    let value = unsafe {
+                        CStr::from_ptr((*optional_field).fld_value)
+                            .to_str()
+                            .unwrap_or_default()
+                    };

-                    if let Ok(test) = Self::from_str(&value) {
+                    if let Ok(test) = Self::from_str(value) {
                        if addr_cmp(&test.addr, wanted_from) {
                            if fine_header.is_none() {
                                fine_header = Some(test);
--- a/src/configure/auto_mozilla.rs
+++ b/src/configure/auto_mozilla.rs
@@ -10,29 +10,16 @@ use super::read_autoconf_file;
 * Thunderbird's Autoconfigure
 ******************************************************************************/
 /* documentation: https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration */
-struct MozAutoconfigure<'a> {
+#[repr(C)]
+struct moz_autoconfigure_t<'a> {
    pub in_0: &'a LoginParam,
    pub in_emaildomain: &'a str,
    pub in_emaillocalpart: &'a str,
    pub out: LoginParam,
-    pub out_imap_set: bool,
-    pub out_smtp_set: bool,
-    pub tag_server: MozServer,
-    pub tag_config: MozConfigTag,
-}
-
-enum MozServer {
-    Undefined,
-    Imap,
-    Smtp,
-}
-
-enum MozConfigTag {
-    Undefined,
-    Hostname,
-    Port,
-    Sockettype,
-    Username,
+    pub out_imap_set: libc::c_int,
+    pub out_smtp_set: libc::c_int,
+    pub tag_server: libc::c_int,
+    pub tag_config: libc::c_int,
 }

 pub fn moz_autoconfigure(
@@ -40,11 +27,20 @@ pub fn moz_autoconfigure(
    url: &str,
    param_in: &LoginParam,
 ) -> Option<LoginParam> {
-    let xml_raw = read_autoconf_file(context, url)?;
+    let xml_raw = match read_autoconf_file(context, url) {
+        Err(err) => {
+            info!(context, "can't read file: {}", err);
+            return None;
+        }
+        Ok(content) => content,
+    };

    // Split address into local part and domain part.
-    let p = param_in.addr.find('@')?;
-    let (in_emaillocalpart, in_emaildomain) = param_in.addr.split_at(p);
+    let p = param_in.addr.find("@");
+    if p.is_none() {
+        return None;
+    }
+    let (in_emaillocalpart, in_emaildomain) = param_in.addr.split_at(p.unwrap());
    let in_emaildomain = &in_emaildomain[1..];

    let mut reader = quick_xml::Reader::from_str(&xml_raw);
@@ -52,15 +48,15 @@ pub fn moz_autoconfigure(

    let mut buf = Vec::new();

-    let mut moz_ac = MozAutoconfigure {
+    let mut moz_ac = moz_autoconfigure_t {
        in_0: param_in,
        in_emaildomain,
        in_emaillocalpart,
        out: LoginParam::new(),
-        out_imap_set: false,
-        out_smtp_set: false,
-        tag_server: MozServer::Undefined,
-        tag_config: MozConfigTag::Undefined,
+        out_imap_set: 0,
+        out_smtp_set: 0,
+        tag_server: 0,
+        tag_config: 0,
    };
    loop {
        match reader.read_event(&mut buf) {
@@ -72,7 +68,7 @@ pub fn moz_autoconfigure(
                moz_autoconfigure_text_cb(e, &mut moz_ac, &reader)
            }
            Err(e) => {
-                warn!(
+                error!(
                    context,
                    "Configure xml: Error at position {}: {:?}",
                    reader.buffer_position(),
@@ -100,7 +96,7 @@ pub fn moz_autoconfigure(

 fn moz_autoconfigure_text_cb<B: std::io::BufRead>(
    event: &BytesText,
-    moz_ac: &mut MozAutoconfigure,
+    moz_ac: &mut moz_autoconfigure_t,
    reader: &quick_xml::Reader<B>,
 ) {
    let val = event.unescape_and_decode(reader).unwrap_or_default();
@@ -115,12 +111,12 @@ fn moz_autoconfigure_text_cb<B: std::io::BufRead>(
        .replace("%EMAILLOCALPART%", email_local)
        .replace("%EMAILDOMAIN%", email_domain);

-    match moz_ac.tag_server {
-        MozServer::Imap => match moz_ac.tag_config {
-            MozConfigTag::Hostname => moz_ac.out.mail_server = val,
-            MozConfigTag::Port => moz_ac.out.mail_port = val.parse().unwrap_or_default(),
-            MozConfigTag::Username => moz_ac.out.mail_user = val,
-            MozConfigTag::Sockettype => {
+    if moz_ac.tag_server == 1 {
+        match moz_ac.tag_config {
+            10 => moz_ac.out.mail_server = val,
+            11 => moz_ac.out.mail_port = val.parse().unwrap_or_default(),
+            12 => moz_ac.out.mail_user = val,
+            13 => {
                let val_lower = val.to_lowercase();
                if val_lower == "ssl" {
                    moz_ac.out.server_flags |= DC_LP_IMAP_SOCKET_SSL as i32
@@ -133,12 +129,13 @@ fn moz_autoconfigure_text_cb<B: std::io::BufRead>(
                }
            }
            _ => {}
-        },
-        MozServer::Smtp => match moz_ac.tag_config {
-            MozConfigTag::Hostname => moz_ac.out.send_server = val,
-            MozConfigTag::Port => moz_ac.out.send_port = val.parse().unwrap_or_default(),
-            MozConfigTag::Username => moz_ac.out.send_user = val,
-            MozConfigTag::Sockettype => {
+        }
+    } else if moz_ac.tag_server == 2 {
+        match moz_ac.tag_config {
+            10 => moz_ac.out.send_server = val,
+            11 => moz_ac.out.send_port = val.parse().unwrap_or_default(),
+            12 => moz_ac.out.send_user = val,
+            13 => {
                let val_lower = val.to_lowercase();
                if val_lower == "ssl" {
                    moz_ac.out.server_flags |= DC_LP_SMTP_SOCKET_SSL as i32
@@ -151,30 +148,29 @@ fn moz_autoconfigure_text_cb<B: std::io::BufRead>(
                }
            }
            _ => {}
-        },
-        MozServer::Undefined => {}
+        }
    }
 }

-fn moz_autoconfigure_endtag_cb(event: &BytesEnd, moz_ac: &mut MozAutoconfigure) {
+fn moz_autoconfigure_endtag_cb(event: &BytesEnd, moz_ac: &mut moz_autoconfigure_t) {
    let tag = String::from_utf8_lossy(event.name()).trim().to_lowercase();

    if tag == "incomingserver" {
-        moz_ac.tag_server = MozServer::Undefined;
-        moz_ac.tag_config = MozConfigTag::Undefined;
-        moz_ac.out_imap_set = true;
+        moz_ac.tag_server = 0;
+        moz_ac.tag_config = 0;
+        moz_ac.out_imap_set = 1;
    } else if tag == "outgoingserver" {
-        moz_ac.tag_server = MozServer::Undefined;
-        moz_ac.tag_config = MozConfigTag::Undefined;
-        moz_ac.out_smtp_set = true;
+        moz_ac.tag_server = 0;
+        moz_ac.tag_config = 0;
+        moz_ac.out_smtp_set = 1;
    } else {
-        moz_ac.tag_config = MozConfigTag::Undefined;
+        moz_ac.tag_config = 0;
    }
 }

 fn moz_autoconfigure_starttag_cb<B: std::io::BufRead>(
    event: &BytesStart,
-    moz_ac: &mut MozAutoconfigure,
+    moz_ac: &mut moz_autoconfigure_t,
    reader: &quick_xml::Reader<B>,
 ) {
    let tag = String::from_utf8_lossy(event.name()).trim().to_lowercase();
@@ -191,29 +187,25 @@ fn moz_autoconfigure_starttag_cb<B: std::io::BufRead>(
                .unwrap_or_default()
                .to_lowercase();

-            if typ == "imap" && !moz_ac.out_imap_set {
-                MozServer::Imap
+            if typ == "imap" && moz_ac.out_imap_set == 0 {
+                1
            } else {
-                MozServer::Undefined
+                0
            }
        } else {
-            MozServer::Undefined
+            0
        };
-        moz_ac.tag_config = MozConfigTag::Undefined;
+        moz_ac.tag_config = 0;
    } else if tag == "outgoingserver" {
-        moz_ac.tag_server = if !moz_ac.out_smtp_set {
-            MozServer::Smtp
-        } else {
-            MozServer::Undefined
-        };
-        moz_ac.tag_config = MozConfigTag::Undefined;
+        moz_ac.tag_server = if moz_ac.out_smtp_set == 0 { 2 } else { 0 };
+        moz_ac.tag_config = 0;
    } else if tag == "hostname" {
-        moz_ac.tag_config = MozConfigTag::Hostname;
+        moz_ac.tag_config = 10;
    } else if tag == "port" {
-        moz_ac.tag_config = MozConfigTag::Port;
+        moz_ac.tag_config = 11;
    } else if tag == "sockettype" {
-        moz_ac.tag_config = MozConfigTag::Sockettype;
+        moz_ac.tag_config = 13;
    } else if tag == "username" {
-        moz_ac.tag_config = MozConfigTag::Username;
+        moz_ac.tag_config = 12;
    }
 }
--- a/src/configure/auto_outlook.rs
+++ b/src/configure/auto_outlook.rs
@@ -1,157 +1,137 @@
+use std::collections::HashMap;
 use quick_xml;
-use quick_xml::events::BytesEnd;

 use crate::constants::*;
 use crate::context::Context;
 use crate::login_param::LoginParam;
+use quick_xml::events::{BytesEnd};

 use super::read_autoconf_file;
-
-/// Outlook's Autodiscover
-struct OutlookAutodiscover {
+/* ******************************************************************************
+ * Outlook's Autodiscover
+ ******************************************************************************/
+#[repr(C)]
+struct outlk_autodiscover_t<'a> {
+    pub in_0: &'a LoginParam,
    pub out: LoginParam,
    pub out_imap_set: bool,
    pub out_smtp_set: bool,
-    pub config_type: Option<String>,
-    pub config_server: String,
-    pub config_port: i32,
-    pub config_ssl: String,
-    pub config_redirecturl: Option<String>,
+    pub config: HashMap<String, String>,
 }

 pub fn outlk_autodiscover(
    context: &Context,
-    url: &str,
-    _param_in: &LoginParam,
+    url__: &str,
+    param_in: &LoginParam,
 ) -> Option<LoginParam> {
-    let mut url = url.to_string();
-    /* Follow up to 10 xml-redirects (http-redirects are followed in read_autoconf_file() */
-    for _i in 0..10 {
-        let mut outlk_ad = OutlookAutodiscover {
-            out: LoginParam::new(),
-            out_imap_set: false,
-            out_smtp_set: false,
-            config_type: None,
-            config_server: String::new(),
-            config_port: 0,
-            config_ssl: String::new(),
-            config_redirecturl: None,
-        };
+    let mut url = url__.to_string();
+    let mut outlk_ad = outlk_autodiscover_t {
+        in_0: param_in,
+        out: LoginParam::new(),
+        out_imap_set: false,
+        out_smtp_set: false,
+        config: HashMap::new(),
+    };
+    for i in 0..10 {
+        let xml_raw = read_autoconf_file(context, &url);
+        if xml_raw.is_err() {
+            return Some(outlk_ad.out);
+        }
+        let xml_raw = xml_raw.unwrap();

-        if let Some(xml_raw) = read_autoconf_file(context, &url) {
-            let mut reader = quick_xml::Reader::from_str(&xml_raw);
-            reader.trim_text(true);
+        let mut reader = quick_xml::Reader::from_str(&xml_raw);
+        reader.trim_text(true);

-            let mut buf = Vec::new();
-
-            let mut current_tag: Option<String> = None;
-
-            loop {
-                match reader.read_event(&mut buf) {
-                    Ok(quick_xml::events::Event::Start(ref e)) => {
-                        let tag = String::from_utf8_lossy(e.name()).trim().to_lowercase();
-
-                        if tag == "protocol" {
-                            outlk_ad.config_type = None;
-                            outlk_ad.config_server = String::new();
-                            outlk_ad.config_port = 0;
-                            outlk_ad.config_ssl = String::new();
-                            outlk_ad.config_redirecturl = None;
-
-                            current_tag = None;
-                        } else {
-                            current_tag = Some(tag);
-                        }
+        let mut buf = Vec::new();
+        let current_tag: Option<String> = None;
+        loop {
+            match reader.read_event(&mut buf) {
+                Ok(quick_xml::events::Event::Start(ref e)) => {
+                    current_tag = Some(String::from_utf8_lossy(e.name()).trim().to_lowercase());
+                }
+                Ok(quick_xml::events::Event::End(ref e)) => {
+                    if "protocol" == String::from_utf8_lossy(e.name()).trim().to_lowercase() {
+                        finish_settings(e, &mut outlk_ad);
                    }
-                    Ok(quick_xml::events::Event::End(ref e)) => {
-                        outlk_autodiscover_endtag_cb(e, &mut outlk_ad);
-                        current_tag = None;
-                    }
-                    Ok(quick_xml::events::Event::Text(ref e)) => {
+                    current_tag = None;
+                }
+                Ok(quick_xml::events::Event::Text(ref e)) => {
+                    if let Some(current_tag) = current_tag {
                        let val = e.unescape_and_decode(&reader).unwrap_or_default();
-
-                        if let Some(ref tag) = current_tag {
-                            match tag.as_str() {
-                                "type" => outlk_ad.config_type = Some(val.trim().to_string()),
-                                "server" => outlk_ad.config_server = val.trim().to_string(),
-                                "port" => {
-                                    outlk_ad.config_port = val.trim().parse().unwrap_or_default()
-                                }
-                                "ssl" => outlk_ad.config_ssl = val.trim().to_string(),
-                                "redirecturl" => {
-                                    outlk_ad.config_redirecturl = Some(val.trim().to_string())
-                                }
-                                _ => {}
-                            };
-                        }
+                        &outlk_ad.config.insert(current_tag, val);
                    }
-                    Err(e) => {
-                        error!(
-                            context,
-                            "Configure xml: Error at position {}: {:?}",
-                            reader.buffer_position(),
-                            e
-                        );
-                    }
-                    Ok(quick_xml::events::Event::Eof) => break,
-                    _ => (),
                }
-                buf.clear();
-            }
-
-            // XML redirect via redirecturl
-            if outlk_ad.config_redirecturl.is_none()
-                || outlk_ad.config_redirecturl.as_ref().unwrap().is_empty()
-            {
-                if outlk_ad.out.mail_server.is_empty()
-                    || outlk_ad.out.mail_port == 0
-                    || outlk_ad.out.send_server.is_empty()
-                    || outlk_ad.out.send_port == 0
-                {
-                    let r = outlk_ad.out.to_string();
-                    warn!(context, "Bad or incomplete autoconfig: {}", r,);
-                    return None;
+                Err(e) => {
+                    error!(
+                        context,
+                        "Configure xml: Error at position {}: {:?}",
+                        reader.buffer_position(),
+                        e
+                    );
+                    break;
                }
-                return Some(outlk_ad.out);
-            } else {
-                url = outlk_ad.config_redirecturl.unwrap();
+                Ok(quick_xml::events::Event::Eof) => break,
+                _ => (),
            }
-        } else {
-            return None;
+            buf.clear();
        }
+        if let Some(next_url) = outlk_ad.config.get("redirecturl") {
+            if !next_url.is_empty() {
+                url = next_url.to_string();
+                continue;
+            }
+        }
+        break;
    }
-    None
+
+    if outlk_ad.out.mail_server.is_empty()
+        || outlk_ad.out.mail_port == 0
+        || outlk_ad.out.send_server.is_empty()
+        || outlk_ad.out.send_port == 0
+    {
+        let r = outlk_ad.out.to_string();
+        warn!(context, "Bad or incomplete autoconfig: {}", r,);
+
+        return None;
+    }
+    Some(outlk_ad.out)
 }

-fn outlk_autodiscover_endtag_cb(event: &BytesEnd, outlk_ad: &mut OutlookAutodiscover) {
-    let tag = String::from_utf8_lossy(event.name()).trim().to_lowercase();
-
-    if tag == "protocol" {
-        if let Some(type_) = &outlk_ad.config_type {
-            let port = outlk_ad.config_port;
-            let ssl_on = outlk_ad.config_ssl == "on";
-            let ssl_off = outlk_ad.config_ssl == "off";
-            if type_ == "imap" && !outlk_ad.out_imap_set {
-                outlk_ad.out.mail_server =
-                    std::mem::replace(&mut outlk_ad.config_server, String::new());
-                outlk_ad.out.mail_port = port;
-                if ssl_on {
-                    outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_SSL as i32
-                } else if ssl_off {
-                    outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_PLAIN as i32
-                }
-                outlk_ad.out_imap_set = true
-            } else if type_ == "smtp" && !outlk_ad.out_smtp_set {
-                outlk_ad.out.send_server =
-                    std::mem::replace(&mut outlk_ad.config_server, String::new());
-                outlk_ad.out.send_port = outlk_ad.config_port;
-                if ssl_on {
-                    outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_SSL as i32
-                } else if ssl_off {
-                    outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_PLAIN as i32
-                }
-                outlk_ad.out_smtp_set = true
+fn finish_settings(event: &BytesEnd, outlk_ad: &mut outlk_autodiscover_t) {
+    let ssl_on = false;
+    let ssl_off = false;
+    let config = &outlk_ad.config;
+    if let Some(type_val) = &config.get("type") {
+        let port = match config.get("port") {
+            None => 0,
+            Some(r) => {
+                r.parse::<i32>().unwrap_or_default()
            }
+        };
+        if let Some(ssl) = &config.get("ssl") {
+            ssl_on = *ssl == "on";
+            ssl_off = *ssl == "off";
+        }
+        let type_val = *type_val;
+        if !outlk_ad.out_imap_set && type_val == "imap" {
+            outlk_ad.out.mail_server = config.get("server").unwrap_or("".to_string());
+            outlk_ad.out.mail_port = port;
+            if ssl_on {
+                outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_SSL as i32;
+            } else if ssl_off {
+                outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_PLAIN as i32;
+            }
+            outlk_ad.out_imap_set = true;
+        } else if !outlk_ad.out_smtp_set && type_val == "smtp" {
+            outlk_ad.out.send_server = &config.get("server").unwrap_or_default();
+            outlk_ad.out.send_port = port;
+
+            if ssl_on {
+                outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_SSL as i32
+            } else if ssl_off {
+                outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_PLAIN as i32
+            }
+            outlk_ad.out_smtp_set = true;
        }
    }
 }
--- a/src/configure/mod.rs
+++ b/src/configure/mod.rs
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -129,23 +129,23 @@ pub const DC_CREATE_MVBOX: usize = 1;
 /// Force OAuth2 authorization. This flag does not skip automatic configuration.
 /// Before calling configure() with DC_LP_AUTH_OAUTH2 set,
 /// the user has to confirm access at the URL returned by dc_get_oauth2_url().
-pub const DC_LP_AUTH_OAUTH2: i32 = 0x2;
+pub const DC_LP_AUTH_OAUTH2: usize = 0x2;

 /// Force NORMAL authorization, this is the default.
 /// If this flag is set, automatic configuration is skipped.
-pub const DC_LP_AUTH_NORMAL: i32 = 0x4;
+pub const DC_LP_AUTH_NORMAL: usize = 0x4;

 /// Connect to IMAP via STARTTLS.
 /// If this flag is set, automatic configuration is skipped.
-pub const DC_LP_IMAP_SOCKET_STARTTLS: i32 = 0x100;
+pub const DC_LP_IMAP_SOCKET_STARTTLS: usize = 0x100;

 /// Connect to IMAP via SSL.
 /// If this flag is set, automatic configuration is skipped.
-pub const DC_LP_IMAP_SOCKET_SSL: i32 = 0x200;
+pub const DC_LP_IMAP_SOCKET_SSL: usize = 0x200;

 /// Connect to IMAP unencrypted, this should not be used.
 /// If this flag is set, automatic configuration is skipped.
-pub const DC_LP_IMAP_SOCKET_PLAIN: i32 = 0x400;
+pub const DC_LP_IMAP_SOCKET_PLAIN: usize = 0x400;

 /// Connect to SMTP via STARTTLS.
 /// If this flag is set, automatic configuration is skipped.
@@ -160,9 +160,9 @@ pub const DC_LP_SMTP_SOCKET_SSL: usize = 0x20000;
 pub const DC_LP_SMTP_SOCKET_PLAIN: usize = 0x40000;

 /// if none of these flags are set, the default is chosen
-pub const DC_LP_AUTH_FLAGS: i32 = (DC_LP_AUTH_OAUTH2 | DC_LP_AUTH_NORMAL);
+pub const DC_LP_AUTH_FLAGS: usize = (DC_LP_AUTH_OAUTH2 | DC_LP_AUTH_NORMAL);
 /// if none of these flags are set, the default is chosen
-pub const DC_LP_IMAP_SOCKET_FLAGS: i32 =
+pub const DC_LP_IMAP_SOCKET_FLAGS: usize =
    (DC_LP_IMAP_SOCKET_STARTTLS | DC_LP_IMAP_SOCKET_SSL | DC_LP_IMAP_SOCKET_PLAIN);
 /// if none of these flags are set, the default is chosen
 pub const DC_LP_SMTP_SOCKET_FLAGS: usize =
@@ -257,7 +257,7 @@ const DC_SHOW_EMAILS_ACCEPTED_CONTACTS: usize = 1;
 const DC_SHOW_EMAILS_ALL: usize = 2;

 // TODO: Strings need some doumentation about used placeholders.
-// These constants are used to set stock translation strings
+// These constants are used to request strings using #DC_EVENT_GET_STRING.

 const DC_STR_NOMESSAGES: usize = 1;
 const DC_STR_SELF: usize = 2;
--- a/src/context.rs
+++ b/src/context.rs
@@ -63,13 +63,12 @@ pub struct Context {
    pub running_state: Arc<RwLock<RunningState>>,
    /// Mutex to avoid generating the key for the user more than once.
    pub generating_key_mutex: Mutex<()>,
-    pub translated_stockstrings: RwLock<HashMap<usize, String>>,
 }

 #[derive(Debug, PartialEq, Eq)]
 pub struct RunningState {
    pub ongoing_running: bool,
-    shall_stop_ongoing: bool,
+    pub shall_stop_ongoing: bool,
 }

 /// Return some info about deltachat-core
@@ -146,7 +145,6 @@ impl Context {
            probe_imap_network: Arc::new(RwLock::new(false)),
            perform_inbox_jobs_needed: Arc::new(RwLock::new(false)),
            generating_key_mutex: Mutex::new(()),
-            translated_stockstrings: RwLock::new(HashMap::new()),
        };

        ensure!(
@@ -222,66 +220,6 @@ impl Context {
        (*self.cb)(self, event)
    }

-    /*******************************************************************************
-     * Ongoing process allocation/free/check
-     ******************************************************************************/
-
-    pub fn alloc_ongoing(&self) -> bool {
-        if self.has_ongoing() {
-            warn!(self, "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
-        }
-    }
-
-    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;
-    }
-
-    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 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.",);
-            s.shall_stop_ongoing = true;
-        } else {
-            info!(self, "No ongoing process to stop.",);
-        };
-    }
-
-    pub fn shall_stop_ongoing(&self) -> bool {
-        self.running_state
-            .clone()
-            .read()
-            .unwrap()
-            .shall_stop_ongoing
-    }
-
-    /*******************************************************************************
-     * UI chat/message related API
-     ******************************************************************************/
-
    pub fn get_info(&self) -> HashMap<&'static str, String> {
        let unset = "0";
        let l = LoginParam::from_database(self, "");
--- a/src/dc_mimeparser.rs
+++ b/src/dc_mimeparser.rs
@@ -606,6 +606,7 @@ impl<'a> MimeParser<'a> {
        let old_part_count = self.parts.len();

        /* regard `Content-Transfer-Encoding:` */
+        let mut ok_to_continue = true;
        let mut desired_filename = String::default();
        let mut simplifier: Option<Simplify> = None;
        match mime_type {
@@ -619,15 +620,19 @@ impl<'a> MimeParser<'a> {
                    && strcmp(charset, b"utf-8\x00" as *const u8 as *const libc::c_char) != 0i32
                    && strcmp(charset, b"UTF-8\x00" as *const u8 as *const libc::c_char) != 0i32
                {
-                    if let Some(encoding) =
-                        Charset::for_label(CStr::from_ptr(charset).to_string_lossy().as_bytes())
-                    {
+                    if let Some(encoding) = Charset::for_label(
+                        CStr::from_ptr(charset)
+                            .to_str()
+                            .unwrap_or_default()
+                            .as_bytes(),
+                    ) {
                        let (res, _, _) = encoding.decode(&decoded_data);
                        if res.is_empty() {
                            /* no error - but nothing to add */
-                            return false;
+                            ok_to_continue = false;
+                        } else {
+                            decoded_data = res.as_bytes().to_vec()
                        }
-                        decoded_data = res.as_bytes().to_vec()
                    } else {
                        warn!(
                            self.context,
@@ -637,29 +642,31 @@ impl<'a> MimeParser<'a> {
                        );
                    }
                }
-                /* check header directly as is_send_by_messenger is not yet set up */
-                let is_msgrmsg = self.lookup_optional_field("Chat-Version").is_some();
+                if ok_to_continue {
+                    /* check header directly as is_send_by_messenger is not yet set up */
+                    let is_msgrmsg = self.lookup_optional_field("Chat-Version").is_some();

-                let simplified_txt = if decoded_data.is_empty() {
-                    "".into()
-                } else {
-                    let input = std::string::String::from_utf8_lossy(&decoded_data);
-                    let is_html = mime_type == 70;
+                    let simplified_txt = if decoded_data.is_empty() {
+                        "".into()
+                    } else {
+                        let input = std::string::String::from_utf8_lossy(&decoded_data);
+                        let is_html = mime_type == 70;

-                    simplifier.unwrap().simplify(&input, is_html, is_msgrmsg)
-                };
-                if !simplified_txt.is_empty() {
-                    let mut part = Part::default();
-                    part.typ = Viewtype::Text;
-                    part.mimetype = mime_type;
-                    part.msg = Some(simplified_txt);
-                    part.msg_raw =
-                        Some(std::string::String::from_utf8_lossy(&decoded_data).to_string());
-                    self.do_add_single_part(part);
-                }
+                        simplifier.unwrap().simplify(&input, is_html, is_msgrmsg)
+                    };
+                    if !simplified_txt.is_empty() {
+                        let mut part = Part::default();
+                        part.typ = Viewtype::Text;
+                        part.mimetype = mime_type;
+                        part.msg = Some(simplified_txt);
+                        part.msg_raw =
+                            Some(std::string::String::from_utf8_lossy(&decoded_data).to_string());
+                        self.do_add_single_part(part);
+                    }

-                if simplifier.unwrap().is_forwarded {
-                    self.is_forwarded = true;
+                    if simplifier.unwrap().is_forwarded {
+                        self.is_forwarded = true;
+                    }
                }
            }
            DC_MIMETYPE_IMAGE
@@ -734,29 +741,33 @@ impl<'a> MimeParser<'a> {
                        desired_filename =
                            format!("file.{}", as_str((*(*mime).mm_content_type).ct_subtype));
                    } else {
-                        return false;
+                        ok_to_continue = false;
                    }
                }
-                if desired_filename.starts_with("location") && desired_filename.ends_with(".kml") {
-                    if !decoded_data.is_empty() {
-                        let d = std::string::String::from_utf8_lossy(&decoded_data);
-                        self.location_kml = location::Kml::parse(self.context, &d).ok();
+                if ok_to_continue {
+                    if desired_filename.starts_with("location")
+                        && desired_filename.ends_with(".kml")
+                    {
+                        if !decoded_data.is_empty() {
+                            let d = std::string::String::from_utf8_lossy(&decoded_data);
+                            self.location_kml = location::Kml::parse(self.context, &d).ok();
+                        }
+                    } else if desired_filename.starts_with("message")
+                        && desired_filename.ends_with(".kml")
+                    {
+                        if !decoded_data.is_empty() {
+                            let d = std::string::String::from_utf8_lossy(&decoded_data);
+                            self.message_kml = location::Kml::parse(self.context, &d).ok();
+                        }
+                    } else if !decoded_data.is_empty() {
+                        self.do_add_single_file_part(
+                            msg_type,
+                            mime_type,
+                            raw_mime.as_ref(),
+                            &decoded_data,
+                            &desired_filename,
+                        );
                    }
-                } else if desired_filename.starts_with("message")
-                    && desired_filename.ends_with(".kml")
-                {
-                    if !decoded_data.is_empty() {
-                        let d = std::string::String::from_utf8_lossy(&decoded_data);
-                        self.message_kml = location::Kml::parse(self.context, &d).ok();
-                    }
-                } else if !decoded_data.is_empty() {
-                    self.do_add_single_file_part(
-                        msg_type,
-                        mime_type,
-                        raw_mime.as_ref(),
-                        &decoded_data,
-                        &desired_filename,
-                    );
                }
            }
            _ => {}
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -1,3 +1,4 @@
+use std::ffi::CString;
 use std::ptr;

 use itertools::join;
@@ -435,7 +436,7 @@ unsafe fn add_parts(
                to_ids,
                chat_id,
                &mut chat_id_blocked,
-            )?;
+            );
            if 0 != *chat_id && Blocked::Not != chat_id_blocked && create_blocked == Blocked::Not {
                chat::unblock(context, *chat_id);
                chat_id_blocked = Blocked::Not;
@@ -520,7 +521,7 @@ unsafe fn add_parts(
                    to_ids,
                    chat_id,
                    &mut chat_id_blocked,
-                )?;
+                );
                if 0 != *chat_id && Blocked::Not != chat_id_blocked {
                    chat::unblock(context, *chat_id);
                    chat_id_blocked = Blocked::Not;
@@ -967,7 +968,7 @@ unsafe fn create_or_lookup_group(
    to_ids: &mut Vec<u32>,
    ret_chat_id: *mut u32,
    ret_chat_id_blocked: &mut Blocked,
-) -> Result<()> {
+) {
    let group_explicitly_left: bool;
    let mut chat_id = 0;
    let mut chat_id_blocked = Blocked::Not;
@@ -1052,9 +1053,9 @@ unsafe fn create_or_lookup_group(
                        to_ids,
                        &mut chat_id,
                        &mut chat_id_blocked,
-                    )?;
+                    );
                    cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-                    return Ok(());
+                    return;
                }
            }
        }
@@ -1179,7 +1180,7 @@ unsafe fn create_or_lookup_group(
        }
        if 0 == allow_creation {
            cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-            return Ok(());
+            return;
        }
        chat_id = create_group_record(
            context,
@@ -1207,10 +1208,10 @@ unsafe fn create_or_lookup_group(
                to_ids,
                &mut chat_id,
                &mut chat_id_blocked,
-            )?;
+            );
        }
        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return Ok(());
+        return;
    }

    // execute group commands
@@ -1263,7 +1264,7 @@ unsafe fn create_or_lookup_group(
                } else {
                    chat.param.set(Param::ProfileImage, grpimage);
                }
-                chat.update_param(context)?;
+                chat.update_param(context).unwrap_or_default();
                send_EVENT_CHAT_MODIFIED = 1;
            }
        }
@@ -1327,12 +1328,11 @@ unsafe fn create_or_lookup_group(
                to_ids,
                &mut chat_id,
                &mut chat_id_blocked,
-            )?;
+            );
        }
    }

    cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-    return Ok(());
 }

 /// Handle groups for received messages
@@ -1345,7 +1345,7 @@ unsafe fn create_or_lookup_adhoc_group(
    to_ids: &mut Vec<u32>,
    ret_chat_id: *mut u32,
    ret_chat_id_blocked: &mut Blocked,
-) -> Result<()> {
+) {
    // if we're here, no grpid was found, check there is an existing ad-hoc
    // group matching the to-list or if we can create one
    let mut chat_id = 0;
@@ -1365,7 +1365,7 @@ unsafe fn create_or_lookup_adhoc_group(
    if to_ids.is_empty() || mime_parser.is_mailinglist_message() {
        // too few contacts or a mailinglist
        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return Ok(());
+        return;
    }

    let mut member_ids = to_ids.clone();
@@ -1378,10 +1378,10 @@ unsafe fn create_or_lookup_adhoc_group(
    if member_ids.len() < 3 {
        // too few contacts given
        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return Ok(());
+        return;
    }

-    let chat_ids = search_chat_ids_by_contact_ids(context, &member_ids)?;
+    let chat_ids = search_chat_ids_by_contact_ids(context, &member_ids);
    if !chat_ids.is_empty() {
        let chat_ids_str = join(chat_ids.iter().map(|x| x.to_string()), ",");
        let res = context.sql.query_row(
@@ -1401,13 +1401,13 @@ unsafe fn create_or_lookup_adhoc_group(
            chat_id_blocked = id_blocked;
            /* success, chat found */
            cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-            return Ok(());
+            return;
        }
    }

    if 0 == allow_creation {
        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return Ok(());
+        return;
    }
    // we do not check if the message is a reply to another group, this may result in
    // chats with unclear member list. instead we create a new group in the following lines ...
@@ -1417,7 +1417,7 @@ unsafe fn create_or_lookup_adhoc_group(
    let grpid = create_adhoc_grp_id(context, &member_ids);
    if grpid.is_empty() {
        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return Ok(());
+        return;
    }

    // use subject as initial chat name
@@ -1443,7 +1443,6 @@ unsafe fn create_or_lookup_adhoc_group(
    context.call_cb(Event::ChatModified(chat_id));

    cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-    return Ok(());
 }

 fn create_group_record(
@@ -1521,10 +1520,7 @@ fn hex_hash(s: impl AsRef<str>) -> String {
 }

 #[allow(non_snake_case)]
-fn search_chat_ids_by_contact_ids(
-    context: &Context,
-    unsorted_contact_ids: &Vec<u32>,
-) -> Result<Vec<u32>> {
+fn search_chat_ids_by_contact_ids(context: &Context, unsorted_contact_ids: &Vec<u32>) -> Vec<u32> {
    /* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
    let mut contact_ids = Vec::with_capacity(23);
    let mut chat_ids = Vec::with_capacity(23);
@@ -1579,11 +1575,11 @@ fn search_chat_ids_by_contact_ids(
                    }
                Ok(())
                }
-            )?;
+            ).unwrap_or_default(); // TODO: better error handling
        }
    }

-    Ok(chat_ids)
+    chat_ids
 }

 fn check_verified_properties(
@@ -1685,7 +1681,13 @@ fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {

 unsafe fn dc_is_reply_to_known_message(context: &Context, mime_parser: &MimeParser) -> libc::c_int {
    /* check if the message is a reply to a known message; the replies are identified by the Message-ID from
-    `In-Reply-To`/`References:` (to support non-Delta-Clients) */
+    `In-Reply-To`/`References:` (to support non-Delta-Clients) or from `Chat-Predecessor:` (Delta clients, see comment in dc_chat.c) */
+    if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Predecessor") {
+        let optional_field_c = CString::new(optional_field).unwrap_or_default();
+        if 0 != is_known_rfc724_mid(context, optional_field_c.as_ptr()) {
+            return 1;
+        }
+    }

    if let Some(field) = mime_parser.lookup_field("In-Reply-To") {
        if (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
--- a/src/dc_tools.rs
+++ b/src/dc_tools.rs
@@ -51,6 +51,14 @@ pub unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
    ret
 }

+pub(crate) fn dc_atoi_null_is_0(s: *const libc::c_char) -> libc::c_int {
+    if !s.is_null() {
+        as_str(s).parse().unwrap_or_default()
+    } else {
+        0
+    }
+}
+
 unsafe fn dc_ltrim(buf: *mut libc::c_char) {
    let mut len: libc::size_t;
    let mut cur: *const libc::c_uchar;
@@ -800,7 +808,9 @@ pub fn to_string_lossy(s: *const libc::c_char) -> String {

    let cstr = unsafe { CStr::from_ptr(s) };

-    cstr.to_string_lossy().to_string()
+    cstr.to_str()
+        .map(|s| s.to_string())
+        .unwrap_or_else(|_| cstr.to_string_lossy().to_string())
 }

 pub fn as_str<'a>(s: *const libc::c_char) -> &'a str {
@@ -1329,25 +1339,6 @@ mod tests {
        assert_eq!(grpid, Some("1234567890123456"));
    }

-    #[test]
-    fn test_dc_create_outgoing_rfc724_mid() {
-        // create a normal message-id
-        let mid = dc_create_outgoing_rfc724_mid(None, "foo@bar.de");
-        assert!(mid.starts_with("Mr."));
-        assert!(mid.ends_with("bar.de"));
-        assert!(dc_extract_grpid_from_rfc724_mid(mid.as_str()).is_none());
-
-        // create a message-id containing a group-id
-        let grpid = dc_create_id();
-        let mid = dc_create_outgoing_rfc724_mid(Some(&grpid), "foo@bar.de");
-        assert!(mid.starts_with("Gr."));
-        assert!(mid.ends_with("bar.de"));
-        assert_eq!(
-            dc_extract_grpid_from_rfc724_mid(mid.as_str()),
-            Some(grpid.as_str())
-        );
-    }
-
    #[test]
    fn test_emailaddress_parse() {
        assert_eq!(EmailAddress::new("").is_ok(), false);
--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -263,7 +263,7 @@ pub fn try_decrypt(
    in_out_message: *mut Mailmime,
 ) -> Result<(bool, HashSet<String>, HashSet<String>)> {
    // just a pointer into mailmime structure, must not be freed
-    let imffields = mailmime_find_mailimf_fields(in_out_message);
+    let imffields = unsafe { mailmime_find_mailimf_fields(in_out_message) };
    ensure!(
        !in_out_message.is_null() && !imffields.is_null(),
        "corrupt invalid mime inputs"
--- a/src/events.rs
+++ b/src/events.rs
@@ -2,6 +2,8 @@ use std::path::PathBuf;

 use strum::EnumProperty;

+use crate::stock::StockMessage;
+
 impl Event {
    /// Returns the corresponding Event id.
    pub fn as_id(&self) -> i32 {
@@ -235,4 +237,17 @@ pub enum Event {
    /// @return 0
    #[strum(props(id = "2061"))]
    SecurejoinJoinerProgress { contact_id: u32, progress: usize },
+
+    // the following events are functions that should be provided by the frontends
+    /// Requeste a localized string from the frontend.
+    /// @param data1 (int) ID of the string to request, one of the DC_STR_/// constants.
+    /// @param data2 (int) The count. If the requested string contains a placeholder for a numeric value,
+    ///     the ui may use this value to return different strings on different plural forms.
+    /// @return (const char*) Null-terminated UTF-8 string.
+    ///     The string will be free()'d by the core,
+    ///     so it must be allocated using malloc() or a compatible function.
+    ///     Return 0 if the ui cannot provide the requested string
+    ///     the core will use a default string in english language then.
+    #[strum(props(id = "2091"))]
+    GetString { id: StockMessage, count: usize },
 }
--- a/src/imap.rs
+++ b/src/imap.rs
@@ -384,7 +384,7 @@ impl Imap {
            return true;
        }

-        let server_flags = self.config.read().unwrap().server_flags as i32;
+        let server_flags = self.config.read().unwrap().server_flags;

        let connection_res: imap::error::Result<Client> =
            if (server_flags & (DC_LP_IMAP_SOCKET_STARTTLS | DC_LP_IMAP_SOCKET_PLAIN)) != 0 {
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -1,6 +1,5 @@
-use core::cmp::{max, min};
 use std::ffi::CString;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::ptr;

 use num_traits::FromPrimitive;
@@ -110,48 +109,78 @@ pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<Strin
 }

 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
-}
-
-fn do_initiate_key_transfer(context: &Context) -> Result<String> {
    let mut msg: Message;
+    ensure!(dc_alloc_ongoing(context), "could not allocate ongoing");
    let setup_code = create_setup_code(context);
    /* this may require a keypair to be created. this may take a second ... */
-    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_name = context.new_blob_file(
-        "autocrypt-setup-message.html",
-        setup_file_content.as_bytes(),
-    )?;
+    if !context
+        .running_state
+        .clone()
+        .read()
+        .unwrap()
+        .shall_stop_ongoing
+    {
+        if let Ok(ref setup_file_content) = render_setup_file(context, &setup_code) {
+            /* encrypting may also take a while ... */
+            if !context
+                .running_state
+                .clone()
+                .read()
+                .unwrap()
+                .shall_stop_ongoing
+            {
+                let setup_file_name = context.new_blob_file(
+                    "autocrypt-setup-message.html",
+                    setup_file_content.as_bytes(),
+                )?;
+                {
+                    if let Ok(chat_id) = chat::create_by_contact_id(context, 1) {
+                        msg = Message::default();
+                        msg.type_0 = Viewtype::File;
+                        msg.param.set(Param::File, setup_file_name);

-    let chat_id = chat::create_by_contact_id(context, 1)?;
-    msg = Message::default();
-    msg.type_0 = Viewtype::File;
-    msg.param.set(Param::File, setup_file_name);
+                        msg.param
+                            .set(Param::MimeType, "application/autocrypt-setup");
+                        msg.param.set_int(Param::Cmd, 6);
+                        msg.param
+                            .set_int(Param::ForcePlaintext, DC_FP_NO_AUTOCRYPT_HEADER);

-    msg.param
-        .set(Param::MimeType, "application/autocrypt-setup");
-    msg.param.set_int(Param::Cmd, 6);
-    msg.param
-        .set_int(Param::ForcePlaintext, DC_FP_NO_AUTOCRYPT_HEADER);
-
-    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() {
-        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;
+                        if !context
+                            .running_state
+                            .clone()
+                            .read()
+                            .unwrap()
+                            .shall_stop_ongoing
+                        {
+                            if let Ok(msg_id) = chat::send_msg(context, chat_id, &mut msg) {
+                                info!(context, "Wait for setup message being sent ...",);
+                                loop {
+                                    if context
+                                        .running_state
+                                        .clone()
+                                        .read()
+                                        .unwrap()
+                                        .shall_stop_ongoing
+                                    {
+                                        break;
+                                    }
+                                    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;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
            }
        }
    }
+    dc_free_ongoing(context);
+
    Ok(setup_code)
 }

@@ -390,7 +419,7 @@ pub fn normalize_setup_code(s: &str) -> String {

 #[allow(non_snake_case)]
 pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
-    ensure!(context.alloc_ongoing(), "could not allocate ongoing");
+    ensure!(dc_alloc_ongoing(context), "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();

@@ -402,7 +431,7 @@ pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
    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).is_err() {
-            context.free_ongoing();
+            dc_free_ongoing(context);
            bail!("Cannot create private key or private key not available.");
        } else {
            dc_create_folder(context, &param);
@@ -418,7 +447,7 @@ pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
            bail!("unknown IMEX type");
        }
    };
-    context.free_ongoing();
+    dc_free_ongoing(context);
    match success {
        Ok(()) => {
            info!(context, "IMEX successfully completed");
@@ -484,7 +513,15 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
        |files| {
            for (processed_files_cnt, file) in files.enumerate() {
                let (file_name, file_blob) = file?;
-                ensure!(!context.shall_stop_ongoing(), "received stop signal");
+                if context
+                    .running_state
+                    .clone()
+                    .read()
+                    .unwrap()
+                    .shall_stop_ongoing
+                {
+                    bail!("received stop signal");
+                }
                let mut permille = processed_files_cnt * 1000 / total_files_cnt;
                if permille < 10 {
                    permille = 10
@@ -525,6 +562,10 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
 /* 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. */
 fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
+    let mut ok_to_continue = true;
+    let mut success = false;
+
+    let mut delete_dest_file: libc::c_int = 0;
    // 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);
@@ -551,79 +592,130 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
            s
        );
    }
-    match add_files_to_export(context, &dest_path_filename) {
-        Err(err) => {
-            dc_delete_file(context, &dest_path_filename);
-            error!(context, "backup failed: {}", err);
-            Err(err)
-        }
-        Ok(()) => {
-            context
-                .sql
-                .set_raw_config_int(context, "backup_time", now as i32)?;
-            context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
-            Ok(())
-        }
-    }
-}
-
-fn add_files_to_export(context: &Context, dest_path_filename: &PathBuf) -> 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)
+    /* 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) */
+    /*for logging only*/
    let sql = Sql::new();
-    ensure!(
-        sql.open(context, &dest_path_filename, 0),
-        "could not open db"
-    );
-    if !sql.table_exists("backup_blobs") {
-        sql::execute(
-            context,
-            &sql,
-            "CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);",
-            params![],
-        )?
-    }
-    // copy all files from BLOBDIR into backup-db
-    let mut total_files_cnt = 0;
-    let dir = context.get_blobdir();
-    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)?;
-    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?;
-                ensure!(
-                    !context.shall_stop_ongoing(),
-                    "canceled during export-files"
-                );
-                processed_files_cnt += 1;
-                let permille = max(min(processed_files_cnt * 1000 / total_files_cnt, 990), 10);
-                context.call_cb(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) {
-                    if buf.is_empty() {
-                        continue;
-                    }
-                    // bail out if we can't insert
-                    stmt.execute(params![name, buf])?;
-                }
+    if sql.open(context, &dest_path_filename, 0) {
+        if !sql.table_exists("backup_blobs") {
+            if sql::execute(
+                context,
+                &sql,
+                "CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);",
+                params![],
+            )
+            .is_err()
+            {
+                /* error already logged */
+                ok_to_continue = false;
            }
-            Ok(())
-        },
-    )?;
+        }
+        if ok_to_continue {
+            let mut total_files_cnt = 0;
+            let dir = context.get_blobdir();
+            if let Ok(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);
+                if total_files_cnt > 0 {
+                    // scan directory, pass 2: copy files
+                    if let Ok(dir_handle) = std::fs::read_dir(&dir) {
+                        sql.prepare(
+                                    "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
+                                    move |mut stmt, _| {
+                                        let mut processed_files_cnt = 0;
+                                        for entry in dir_handle {
+                                            if entry.is_err() {
+                                                break;
+                                            }
+                                            let entry = entry.unwrap();
+                                            if context
+                                                .running_state
+                                                .clone()
+                                                .read()
+                                                .unwrap()
+                                                .shall_stop_ongoing
+                                            {
+                                                delete_dest_file = 1;
+                                                ok_to_continue = false;
+                                                break;
+                                            } else {
+                                                processed_files_cnt += 1;
+                                                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));
+
+                                                let name_f = entry.file_name();
+                                                let name = name_f.to_string_lossy();
+                                                if name.starts_with("delta-chat") && name.ends_with(".bak")
+                                                {
+                                                    continue;
+                                                } else {
+                                                    info!(context, "EXPORTing 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;
+                                                        }
+                                                        if stmt.execute(params![name, buf]).is_err() {
+                                                            error!(
+                                                                context,
+                                                                "Disk full? Cannot add file \"{}\" to backup.",
+                                                                curr_path_filename.display(),
+                                                            );
+                                                            /* this is not recoverable! writing to the sqlite database should work! */
+                                                            ok_to_continue = false;
+                                                            break;
+                                                        }
+                                                    } else {
+                                                        continue;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        Ok(())
+                                    }
+                                ).unwrap_or_default();
+                    } else {
+                        error!(
+                            context,
+                            "Backup: Cannot copy from blob-directory \"{}\".",
+                            context.get_blobdir().display(),
+                        );
+                    }
+                } else {
+                    info!(context, "Backup: No files to copy.",);
+                }
+                if ok_to_continue {
+                    if sql
+                        .set_raw_config_int(context, "backup_time", now as i32)
+                        .is_ok()
+                    {
+                        context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
+                        success = true;
+                    }
+                }
+            } else {
+                error!(
+                    context,
+                    "Backup: Cannot get info for blob-directory \"{}\".",
+                    context.get_blobdir().display(),
+                );
+            };
+        }
+    }
+    if 0 != delete_dest_file {
+        dc_delete_file(context, &dest_path_filename);
+    }
+
+    ensure!(success, "failed");
    Ok(())
 }

@@ -642,68 +734,77 @@ 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 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);
-        match dc_get_filesuffix_lc(&name_f) {
-            Some(suffix) => {
-                if suffix != "asc" {
+    if let Ok(dir_handle) = std::fs::read_dir(&dir) {
+        for entry in dir_handle {
+            let entry_fn = match entry {
+                Err(err) => {
+                    info!(context, "file-dir error: {}", err);
+                    break;
+                }
+                Ok(res) => res.file_name(),
+            };
+            let name_f = entry_fn.to_string_lossy();
+            let path_plus_name = dir.as_ref().join(&entry_fn);
+            match dc_get_filesuffix_lc(&name_f) {
+                Some(suffix) => {
+                    if suffix != "asc" {
+                        continue;
+                    }
+                    set_default = if name_f.contains("legacy") {
+                        info!(context, "found legacy key '{}'", path_plus_name.display());
+                        false
+                    } else {
+                        true
+                    }
+                }
+                None => {
                    continue;
                }
-                set_default = if name_f.contains("legacy") {
-                    info!(context, "found legacy key '{}'", path_plus_name.display());
-                    false
-                } else {
-                    true
-                }
            }
-            None => {
+            let ccontent = if let Ok(content) = dc_read_file(context, &path_plus_name) {
+                key = String::from_utf8_lossy(&content).to_string();
+                CString::new(content).unwrap_or_default()
+            } else {
+                continue;
+            };
+
+            /* only import if we have a private key */
+            let mut buf2_headerline = String::default();
+            let split_res: bool;
+            unsafe {
+                let buf2 = dc_strdup(ccontent.as_ptr());
+                split_res = dc_split_armored_data(
+                    buf2,
+                    &mut buf2_headerline,
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                );
+                libc::free(buf2 as *mut libc::c_void);
+            }
+            if split_res
+                && buf2_headerline.contains("-----BEGIN PGP PUBLIC KEY BLOCK-----")
+                && !key.contains("-----BEGIN PGP PRIVATE KEY BLOCK")
+            {
+                info!(context, "ignoring public key file '{}", name_f);
+                // it's fine: DC exports public with private
                continue;
            }
+            if let Err(err) = set_self_key(context, &key, set_default, false) {
+                error!(context, "set_self_key: {}", err);
+                continue;
+            }
+            imported_cnt += 1
        }
-        let ccontent = if let Ok(content) = dc_read_file(context, &path_plus_name) {
-            key = String::from_utf8_lossy(&content).to_string();
-            CString::new(content).unwrap_or_default()
-        } else {
-            continue;
-        };
-
-        /* only import if we have a private key */
-        let mut buf2_headerline = String::default();
-        let split_res: bool;
-        unsafe {
-            let buf2 = dc_strdup(ccontent.as_ptr());
-            split_res = dc_split_armored_data(
-                buf2,
-                &mut buf2_headerline,
-                ptr::null_mut(),
-                ptr::null_mut(),
-                ptr::null_mut(),
-            );
-            libc::free(buf2 as *mut libc::c_void);
-        }
-        if split_res
-            && buf2_headerline.contains("-----BEGIN PGP PUBLIC KEY BLOCK-----")
-            && !key.contains("-----BEGIN PGP PRIVATE KEY BLOCK")
-        {
-            info!(context, "ignoring public key file '{}", name_f);
-            // it's fine: DC exports public with private
-            continue;
-        }
-        if let Err(err) = set_self_key(context, &key, set_default, false) {
-            error!(context, "set_self_key: {}", err);
-            continue;
-        }
-        imported_cnt += 1
+        ensure!(
+            imported_cnt > 0,
+            "No private keys found in \"{}\".",
+            dir_name
+        );
+        Ok(())
+    } else {
+        bail!("Import: Cannot open directory \"{}\".", dir_name);
    }
-    ensure!(
-        imported_cnt > 0,
-        "No private keys found in \"{}\".",
-        dir_name
-    );
-    Ok(())
 }

 fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
@@ -746,7 +847,7 @@ fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
        },
    )?;

-    ensure!(export_errors == 0, "errors while exporting keys");
+    ensure!(export_errors == 0, "errors while importing");
    Ok(())
 }

@@ -805,12 +906,19 @@ mod tests {
        assert!(msg.contains("-----END PGP MESSAGE-----\n"));
    }

+    fn ac_setup_msg_cb(ctx: &Context, evt: Event) -> libc::uintptr_t {
+        match evt {
+            Event::GetString {
+                id: StockMessage::AcSetupMsgBody,
+                ..
+            } => unsafe { "hello\r\nthere".strdup() as usize },
+            _ => logging_cb(ctx, evt),
+        }
+    }
+
    #[test]
-    fn test_render_setup_file_newline_replace() {
-        let t = dummy_context();
-        t.ctx
-            .set_stock_translation(StockMessage::AcSetupMsgBody, "hello\r\nthere".to_string())
-            .unwrap();
+    fn otest_render_setup_file_newline_replace() {
+        let t = test_context(Some(Box::new(ac_setup_msg_cb)));
        configure_alice_keypair(&t.ctx);
        let msg = render_setup_file(&t.ctx, "pw").unwrap();
        println!("{}", &msg);
--- a/src/job.rs
+++ b/src/job.rs
@@ -12,7 +12,7 @@ use crate::dc_tools::*;
 use crate::error::Error;
 use crate::events::Event;
 use crate::imap::*;
-use crate::imex::*;
+use crate::imex::job_do_DC_JOB_IMEX_IMAP;
 use crate::location;
 use crate::login_param::LoginParam;
 use crate::message::{self, Message, MessageState};
@@ -781,13 +781,8 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
                Action::MarkseenMdnOnImap => job.do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context),
                Action::MoveMsg => job.do_DC_JOB_MOVE_MSG(context),
                Action::SendMdn => job.do_DC_JOB_SEND(context),
+                Action::ImexImap => job_do_DC_JOB_IMEX_IMAP(context, &job),
                Action::ConfigureImap => dc_job_do_DC_JOB_CONFIGURE_IMAP(context),
-                Action::ImexImap => match job_do_DC_JOB_IMEX_IMAP(context, &job) {
-                    Ok(()) => {}
-                    Err(err) => {
-                        error!(context, "{}", err);
-                    }
-                },
                Action::MaybeSendLocations => {
                    location::job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context, &job)
                }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -57,7 +57,7 @@ pub mod qr;
 pub mod securejoin;
 mod smtp;
 pub mod sql;
-pub mod stock;
+mod stock;
 mod token;
 #[macro_use]
 mod wrapmime;
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -671,28 +671,31 @@ impl<'a> MimeFactory<'a> {
                .push(factory.from_displayname.to_string());
            factory.recipients_addr.push(factory.from_addr.to_string());
        } else {
-            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;",
-                params![factory.msg.chat_id as i32],
-                |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 !vec_contains_lowercase(&factory.recipients_addr, &addr) {
-                            factory.recipients_addr.push(addr);
-                            factory.recipients_names.push(authname);
+            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;",
+                    params![factory.msg.chat_id as i32],
+                    |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 !vec_contains_lowercase(&factory.recipients_addr, &addr) {
+                                factory.recipients_addr.push(addr);
+                                factory.recipients_names.push(authname);
+                            }
                        }
-                    }
-                    Ok(())
-                },
-            )?;
+                        Ok(())
+                    },
+                )
+                .unwrap_or_default();

            let command = factory.msg.param.get_cmd();
            let msg = &factory.msg;
@@ -895,7 +898,9 @@ fn build_body_file(
        wrapmime::append_ct_param(content, "name", &filename_encoded)?;

        let mime_sub = mailmime_new_empty(content, mime_fields);
-        let abs_path = dc_get_abs_path(context, path_filename).to_c_string()?;
+        let abs_path = dc_get_abs_path(context, path_filename)
+            .to_c_string()
+            .unwrap_or_default();
        mailmime_set_body_file(mime_sub, dc_strdup(abs_path.as_ptr()));
        Ok((mime_sub, filename_to_send))
    }
--- a/src/securejoin.rs
+++ b/src/securejoin.rs
@@ -3,6 +3,7 @@ use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};
 use crate::aheader::EncryptPreference;
 use crate::chat::{self, Chat};
 use crate::config::*;
+use crate::configure::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
@@ -156,7 +157,7 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
            bob.qr_scan = None;

            if ongoing_allocated {
-                context.free_ongoing();
+                dc_free_ongoing(context);
            }
            ret_chat_id as u32
        };
@@ -169,7 +170,7 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {

    info!(context, "Requesting secure-join ...",);
    ensure_secret_key_exists(context).ok();
-    if !context.alloc_ongoing() {
+    if !dc_alloc_ongoing(context) {
        return cleanup(&context, contact_chat_id, false, join_vg);
    }
    let qr_scan = check_qr(context, &qr);
@@ -183,7 +184,7 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
        error!(context, "Unknown contact.",);
        return cleanup(&context, contact_chat_id, true, join_vg);
    }
-    if context.shall_stop_ongoing() {
+    if check_exit(context) {
        return cleanup(&context, contact_chat_id, true, join_vg);
    }
    join_vg = qr_scan.get_state() == LotState::QrAskVerifyGroup;
@@ -239,12 +240,21 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
    }

    // Bob -> Alice
-    while !context.shall_stop_ongoing() {
+    while !check_exit(&context) {
        std::thread::sleep(std::time::Duration::new(0, 3_000_000));
    }
    cleanup(&context, contact_chat_id, true, join_vg)
 }

+fn check_exit(context: &Context) -> bool {
+    context
+        .running_state
+        .clone()
+        .read()
+        .unwrap()
+        .shall_stop_ongoing
+}
+
 fn send_handshake_msg(
    context: &Context,
    contact_chat_id: u32,
@@ -626,7 +636,7 @@ pub fn handle_securejoin_handshake(

 fn end_bobs_joining(context: &Context, status: libc::c_int) {
    context.bob.write().unwrap().status = status;
-    context.stop_ongoing();
+    dc_stop_ongoing_process(context);
 }

 fn secure_connection_established(context: &Context, contact_chat_id: u32) {
--- a/src/stock.rs
+++ b/src/stock.rs
@@ -5,7 +5,8 @@ use strum_macros::EnumProperty;

 use crate::contact::*;
 use crate::context::Context;
-use crate::error::Error;
+use crate::dc_tools::*;
+use crate::events::Event;

 /// Stock strings
 ///
@@ -122,47 +123,19 @@ impl StockMessage {
 }

 impl Context {
-    /// Set the stock string for the [StockMessage].
-    ///
-    pub fn set_stock_translation(
-        &self,
-        id: StockMessage,
-        stockstring: String,
-    ) -> Result<(), Error> {
-        if stockstring.contains("%1") && !id.fallback().contains("%1") {
-            bail!(
-                "translation {} contains invalid %1 placeholder, default is {}",
-                stockstring,
-                id.fallback()
-            );
-        }
-        if stockstring.contains("%2") && !id.fallback().contains("%2") {
-            bail!(
-                "translation {} contains invalid %2 placeholder, default is {}",
-                stockstring,
-                id.fallback()
-            );
-        }
-        self.translated_stockstrings
-            .write()
-            .unwrap()
-            .insert(id as usize, stockstring);
-        Ok(())
-    }
-
    /// Return the stock string for the [StockMessage].
    ///
-    /// Return a translation (if it was set with set_stock_translation before)
-    /// or a default (English) string.
+    /// If the context callback responds with a string to use, e.g. a
+    /// translation, then this string will be returned.  Otherwise a
+    /// default (English) string is returned.
    pub fn stock_str(&self, id: StockMessage) -> Cow<str> {
-        match self
-            .translated_stockstrings
-            .read()
-            .unwrap()
-            .get(&(id as usize))
-        {
-            Some(ref x) => Cow::Owned(x.to_string()),
-            None => Cow::Borrowed(id.fallback()),
+        let ptr = self.call_cb(Event::GetString { id, count: 0 }) as *mut libc::c_char;
+        if ptr.is_null() {
+            Cow::Borrowed(id.fallback())
+        } else {
+            let ret = to_string_lossy(ptr);
+            unsafe { libc::free(ptr as *mut libc::c_void) };
+            Cow::Owned(ret)
        }
    }

@@ -266,6 +239,7 @@ mod tests {
    use crate::test_utils::*;

    use crate::constants::DC_CONTACT_ID_SELF;
+    use libc::uintptr_t;

    use num_traits::ToPrimitive;

@@ -280,34 +254,28 @@ mod tests {
        assert_eq!(StockMessage::NoMessages.fallback(), "No messages.");
    }

-    #[test]
-    fn test_set_stock_translation() {
-        let t = dummy_context();
-        t.ctx
-            .set_stock_translation(StockMessage::NoMessages, "xyz".to_string())
-            .unwrap();
-        assert_eq!(t.ctx.stock_str(StockMessage::NoMessages), "xyz")
-    }
-
-    #[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())
-            .is_err());
-        assert!(t
-            .ctx
-            .set_stock_translation(StockMessage::NoMessages, "xyz %2$s ".to_string())
-            .is_err());
-    }
-
    #[test]
    fn test_stock_str() {
        let t = dummy_context();
        assert_eq!(t.ctx.stock_str(StockMessage::NoMessages), "No messages.");
    }

+    fn test_stock_str_no_fallback_cb(_ctx: &Context, evt: Event) -> uintptr_t {
+        match evt {
+            Event::GetString {
+                id: StockMessage::NoMessages,
+                ..
+            } => unsafe { "Hello there".strdup() as usize },
+            _ => 0,
+        }
+    }
+
+    #[test]
+    fn test_stock_str_no_fallback() {
+        let t = test_context(Some(Box::new(test_stock_str_no_fallback_cb)));
+        assert_eq!(t.ctx.stock_str(StockMessage::NoMessages), "Hello there");
+    }
+
    #[test]
    fn test_stock_string_repl_str() {
        let t = dummy_context();
--- a/src/top_evil_rs.py
+++ b/src/top_evil_rs.py
@@ -14,24 +14,24 @@ if __name__ == "__main__":
        s = re.sub(r"(?m)///.*$", "", s)  # remove comments
        unsafe = s.count("unsafe")
        free = s.count("free(")
-        unsafe_fn = s.count("unsafe fn")
+        gotoblocks = s.count("ok_to_continue") + s.count('OK_TO_CONTINUE')
        chars = s.count("c_char") + s.count("CStr")
-        filestats.append((fn, unsafe, free, unsafe_fn, chars))
+        filestats.append((fn, unsafe, free, gotoblocks, chars))

-    sum_unsafe, sum_free, sum_unsafe_fn, sum_chars = 0, 0, 0, 0
+    sum_unsafe, sum_free, sum_gotoblocks, sum_chars = 0, 0, 0, 0

-    for fn, unsafe, free, unsafe_fn, chars in reversed(sorted(filestats, key=lambda x: sum(x[1:]))):
-        if unsafe + free + unsafe_fn + chars == 0:
+    for fn, unsafe, free, gotoblocks, chars in reversed(sorted(filestats, key=lambda x: sum(x[1:]))):
+        if unsafe + free + gotoblocks + chars == 0:
            continue
-        print("{0: <25} unsafe: {1: >3} free: {2: >3} unsafe-fn: {3: >3} chars: {4: >3}".format(str(fn), unsafe, free, unsafe_fn, chars))
+        print("{0: <25} unsafe: {1: >3} free: {2: >3} ok_to_cont: {3: >3} chars: {4: >3}".format(str(fn), unsafe, free, gotoblocks, chars))
        sum_unsafe += unsafe
        sum_free += free
-        sum_unsafe_fn += unsafe_fn
+        sum_gotoblocks += gotoblocks
        sum_chars += chars


    print()
    print("total unsafe:", sum_unsafe)
    print("total free:", sum_free)
-    print("total unsafe-fn:", sum_unsafe_fn)
+    print("total ok_to_continue:", sum_gotoblocks)
    print("total c_chars:", sum_chars)
--- a/src/wrapmime.rs
+++ b/src/wrapmime.rs
@@ -175,21 +175,21 @@ pub fn mailimf_find_field(
 }

 /*the result is a pointer to mime, must not be freed*/
-pub fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
+pub unsafe fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
    if mime.is_null() {
        return ptr::null_mut();
    }

-    match unsafe { (*mime).mm_type as _ } {
+    match (*mime).mm_type as _ {
        MAILMIME_MULTIPLE => {
-            for cur_data in unsafe { (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() } {
+            for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
                let header = mailmime_find_mailimf_fields(cur_data as *mut _);
                if !header.is_null() {
                    return header;
                }
            }
        }
-        MAILMIME_MESSAGE => return unsafe { (*mime).mm_data.mm_message.mm_fields },
+        MAILMIME_MESSAGE => return (*mime).mm_data.mm_message.mm_fields,
        _ => {}
    }
Author	SHA1	Message	Date
holger krekel	357bce7246	intermediate commit	2019-10-06 01:28:17 +02:00
holger krekel	6bac21b13f	some more cleanups but not quite working yet	2019-10-06 01:03:13 +02:00
holger krekel	859e7691d0	first round of configure cleanups	2019-10-06 01:00:11 +02:00