change oder of typedefs, function-definitions and defines

as c is top-down, we start with the typedefs
so that functions can use them freely.
after that, the functions are declared
and finally the #defines (for less noise in the function sections).
grouping is done by classes.

.gitattributes

@@ -2,6 +2,10 @@
 # ensures this even if the user has not set core.autocrlf.
 *  text=auto
 
+# This directory contains email messages verbatim, and changing CRLF to
+# LF will corrupt them.
+test-data/* text=false
+
 # binary files should be detected by git, however, to be sure, you can add them here explicitly
 *.png  binary
 *.jpg  binary

Cargo.toml

@@ -5,10 +5,6 @@ authors = ["dignifiedquire <dignifiedquire@gmail.com>"]
 edition = "2018"
 license = "MPL"
 
-[build-dependencies]
-cc = "1.0.35"
-pkg-config = "0.3"
-
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
 libc = "0.2.51"

build.rs

@@ -1,38 +0,0 @@
-extern crate cc;
-
-fn link_static(lib: &str) {
-    println!("cargo:rustc-link-lib=static={}", lib);
-}
-
-fn link_framework(fw: &str) {
-    println!("cargo:rustc-link-lib=framework={}", fw);
-}
-
-fn add_search_path(p: &str) {
-    println!("cargo:rustc-link-search={}", p);
-}
-
-fn build_tools() {
-    let mut config = cc::Build::new();
-    config.file("misc.c").compile("libtools.a");
-
-    println!("rerun-if-changed=build.rs");
-    println!("rerun-if-changed=misc.h");
-    println!("rerun-if-changed=misc.c");
-}
-
-fn main() {
-    build_tools();
-
-    add_search_path("/usr/local/lib");
-
-    let target = std::env::var("TARGET").unwrap();
-    if target.contains("-apple") || target.contains("-darwin") {
-        link_framework("CoreFoundation");
-        link_framework("CoreServices");
-        link_framework("Security");
-    }
-
-    // local tools
-    link_static("tools");
-}

deltachat-ffi/Cargo.toml

@@ -16,6 +16,7 @@ crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
 deltachat = { path = "../", default-features = false }
+deltachat-provider-overview = { git = "https://github.com/deltachat/provider-overview", rev = "366b41a7503973e4ffac3aa5173b419f2f03c211" }
 libc = "0.2"
 human-panic = "1.0.1"
 num-traits = "0.2.6"

deltachat-ffi/deltachat.h

@@ -11,6 +11,16 @@ extern "C" {
 #endif
 
 
+typedef struct _dc_context  dc_context_t;
+typedef struct _dc_array    dc_array_t;
+typedef struct _dc_chatlist dc_chatlist_t;
+typedef struct _dc_chat     dc_chat_t;
+typedef struct _dc_msg      dc_msg_t;
+typedef struct _dc_contact  dc_contact_t;
+typedef struct _dc_lot      dc_lot_t;
+typedef struct _dc_provider dc_provider_t;
+
+
 /**
  * @mainpage Getting started
  *
@@ -189,13 +199,6 @@ extern "C" {
  * SQLite database for offline functionality and for account-related
  * settings.
  */
-typedef struct _dc_context  dc_context_t;
-typedef struct _dc_array    dc_array_t;
-typedef struct _dc_chatlist dc_chatlist_t;
-typedef struct _dc_chat     dc_chat_t;
-typedef struct _dc_msg      dc_msg_t;
-typedef struct _dc_contact  dc_contact_t;
-typedef struct _dc_lot      dc_lot_t;
 
 
 /**
@@ -443,7 +446,6 @@ char*           dc_get_info                  (dc_context_t* context);
 char*           dc_get_oauth2_url            (dc_context_t* context, const char* addr, const char* redirect_uri);
 
 
-
 // connect
 
 /**
@@ -3419,6 +3421,110 @@ int             dc_contact_is_blocked        (const dc_contact_t* contact);
 int             dc_contact_is_verified       (dc_contact_t* contact);
 
 
+/**
+ * @class dc_provider_t
+ *
+ * Opaque object containing information about one single email provider.
+ */
+
+
+/**
+ * Create a provider struct for the given domain.
+ *
+ * @memberof dc_provider_t
+ * @param domain The domain to get provider info for.
+ * @return a dc_provider_t struct which can be used with the dc_provider_get_*
+ *     accessor functions.  If no provider info is found, NULL will be
+ *     returned.
+ */
+dc_provider_t*  dc_provider_new_from_domain           (char* domain);
+
+
+/**
+ * Create a provider struct for the given email address.
+ *
+ * The provider is extracted from the email address and it's information is returned.
+ *
+ * @memberof dc_provider_t
+ * @param email The user's email address to extract the provider info form.
+ * @return a dc_provider_t struct which can be used with the dc_provider_get_*
+ *     accessor functions.  If no provider info is found, NULL will be
+ *     returned.
+ */
+dc_provider_t*  dc_provider_new_from_email            (char* email);
+
+
+/**
+ * URL of the overview page.
+ *
+ * This URL allows linking to the providers page on providers.delta.chat.
+ *
+ * @memberof dc_provider_t
+ * @param provider The dc_provider_t struct.
+ * @return A string which must be free()d.
+ */
+char*           dc_provider_get_overview_page         (const dc_provider_t* provider);
+
+
+/**
+ * The provider's name.
+ *
+ * The name of the provider, e.g. "POSTEO".
+ *
+ * @memberof dc_provider_t
+ * @param provider The dc_provider_t struct.
+ * @return A string which must be free()d.
+ */
+char*           dc_provider_get_name                  (const dc_provider_t* provider);
+
+
+/**
+ * The markdown content of the providers page.
+ *
+ * This contains the preparation steps or additional information if the status
+ * is @ref DC_PROVIDER_STATUS_BROKEN.
+ *
+ * @memberof dc_provider_t
+ * @param provider The dc_provider_t struct.
+ * @return A string which must be free()d.
+ */
+char*           dc_provider_get_markdown              (const dc_provider_t* provider);
+
+
+/**
+ * Date of when the state was last checked/updated.
+ *
+ * This is returned as a string.
+ *
+ * @memberof dc_provider_t
+ * @param provider The dc_provider_t struct.
+ * @return A string which must be free()d.
+ */
+char*           dc_provider_get_status_date           (const dc_provider_t* provider);
+
+
+/**
+ * Whether DC works with this provider.
+ *
+ * Can be one of @ref DC_PROVIDER_STATUS_OK, @ref
+ * DC_PROVIDER_STATUS_PREPARATION and @ref DC_PROVIDER_STATUS_BROKEN.
+ *
+ * @memberof dc_provider_t
+ * @param provider The dc_provider_t struct.
+ * @return The status as a constant number.
+ */
+int             dc_provider_get_status                (const dc_provider_t* provider);
+
+
+/**
+ * Free the provider info struct.
+ *
+ * @memberof dc_provider_t
+ * @param provider The dc_provider_t struct.
+ */
+void            dc_provider_unref                     (const dc_provider_t* provider);
+
+
 /**
  * @class dc_lot_t
  *
@@ -4026,6 +4132,41 @@ void            dc_array_add_id              (dc_array_t*, uint32_t); // depreca
 #define DC_SHOW_EMAILS_ALL               2
 
 
+/**
+ * @defgroup DC_PROVIDER_STATUS DC_PROVIDER_STATUS
+ *
+ * These constants are used as return values for dc_provider_get_status().
+ *
+ * @addtogroup DC_PROVIDER_STATUS
+ * @{
+ */
+
+/**
+ * Provider status returned by dc_provider_get_status().
+ *
+ * Works right out of the box without any preperation steps needed
+ */
+#define         DC_PROVIDER_STATUS_OK           1
+
+/**
+ * Provider status returned by dc_provider_get_status().
+ *
+ * Works, but preparation steps are needed
+ */
+#define         DC_PROVIDER_STATUS_PREPARATION  2
+
+/**
+ * Provider status returned by dc_provider_get_status().
+ *
+ * Doesn't work (too unstable to use falls also in this category)
+ */
+#define         DC_PROVIDER_STATUS_BROKEN       3
+
+/**
+ * @}
+ */
+
+
 /*
  * TODO: Strings need some doumentation about used placeholders.
  *

deltachat-ffi/src/lib.rs

@@ -233,7 +233,7 @@ pub unsafe extern "C" fn dc_open(
     let ffi_context = &*context;
     let rust_cb = move |_ctx: &Context, evt: Event| ffi_context.translate_cb(evt);
 
-    let ctx = if blobdir.is_null() {
+    let ctx = if blobdir.is_null() || *blobdir == 0 {
         Context::new(
             Box::new(rust_cb),
             ffi_context.os_name.clone(),
@@ -2813,6 +2813,8 @@ fn as_opt_str<'a>(s: *const libc::c_char) -> Option<&'a str> {
     Some(dc_tools::as_str(s))
 }
 
+pub mod providers;
+
 pub trait ResultExt<T> {
     fn unwrap_or_log_default(self, context: &context::Context, message: &str) -> T;
     fn log_err(&self, context: &context::Context, message: &str);

deltachat-ffi/src/providers.rs

@@ -0,0 +1,92 @@
+extern crate deltachat_provider_overview;
+
+use std::ptr;
+
+use deltachat::dc_tools::{as_str, StrExt};
+use deltachat_provider_overview::StatusState;
+
+#[no_mangle]
+pub type dc_provider_t = deltachat_provider_overview::Provider;
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_new_from_domain(
+    domain: *const libc::c_char,
+) -> *const dc_provider_t {
+    match deltachat_provider_overview::get_provider_info(as_str(domain)) {
+        Some(provider) => provider,
+        None => ptr::null(),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_new_from_email(
+    email: *const libc::c_char,
+) -> *const dc_provider_t {
+    let domain = deltachat_provider_overview::get_domain_from_email(as_str(email));
+    match deltachat_provider_overview::get_provider_info(domain) {
+        Some(provider) => provider,
+        None => ptr::null(),
+    }
+}
+
+macro_rules! null_guard {
+    ($context:tt) => {
+        if $context.is_null() {
+            return ptr::null_mut() as *mut libc::c_char;
+        }
+    };
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_overview_page(
+    provider: *const dc_provider_t,
+) -> *mut libc::c_char {
+    null_guard!(provider);
+    format!(
+        "{}/{}",
+        deltachat_provider_overview::PROVIDER_OVERVIEW_URL,
+        (*provider).overview_page
+    )
+    .strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_name(provider: *const dc_provider_t) -> *mut libc::c_char {
+    null_guard!(provider);
+    (*provider).name.strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_markdown(
+    provider: *const dc_provider_t,
+) -> *mut libc::c_char {
+    null_guard!(provider);
+    (*provider).markdown.strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_status_date(
+    provider: *const dc_provider_t,
+) -> *mut libc::c_char {
+    null_guard!(provider);
+    (*provider).status.date.strdup()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_get_status(provider: *const dc_provider_t) -> u32 {
+    if provider.is_null() {
+        return 0;
+    }
+    match (*provider).status.state {
+        StatusState::OK => 1,
+        StatusState::PREPARATION => 2,
+        StatusState::BROKEN => 3,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_provider_unref(_provider: *const dc_provider_t) {
+    ()
+}
+
+// TODO expose general provider overview url?

examples/repl/cmdline.rs

@@ -510,18 +510,14 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
         }
         "export-setup" => {
             let setup_code = dc_create_setup_code(context);
-            let file_name: *mut libc::c_char = dc_mprintf(
-                b"%s/autocrypt-setup-message.html\x00" as *const u8 as *const libc::c_char,
-                context.get_blobdir(),
-            );
+            let file_name = context.get_blobdir().join("autocrypt-setup-message.html");
             let file_content = dc_render_setup_file(context, &setup_code)?;
-            std::fs::write(as_str(file_name), file_content)?;
+            std::fs::write(&file_name, file_content)?;
             println!(
                 "Setup message written to: {}\nSetup code: {}",
-                as_str(file_name),
+                file_name.display(),
                 &setup_code,
             );
-            free(file_name as *mut libc::c_void);
         }
         "poke" => {
             ensure!(0 != poke_spec(context, arg1_c), "Poke failed");

misc.c

@@ -1,52 +0,0 @@
-#include <stdlib.h>
-#include <stdarg.h>
-#include <ctype.h>
-#include <string.h>
-#include <stdio.h>
-#include "misc.h"
-
-
-static char* internal_dc_strdup(const char* s) /* strdup(NULL) is undefined, save_strdup(NULL) returns an empty string in this case */
-{
-	char* ret = NULL;
-	if (s) {
-		if ((ret=strdup(s))==NULL) {
-			exit(16); /* cannot allocate (little) memory, unrecoverable error */
-		}
-	}
-	else {
-		if ((ret=(char*)calloc(1, 1))==NULL) {
-			exit(17); /* cannot allocate little memory, unrecoverable error */
-		}
-	}
-	return ret;
-}
-
-char* dc_mprintf(const char* format, ...)
-{
-	char  testbuf[1];
-	char* buf = NULL;
-	int   char_cnt_without_zero = 0;
-
-	va_list argp;
-	va_list argp_copy;
-	va_start(argp, format);
-	va_copy(argp_copy, argp);
-
-	char_cnt_without_zero = vsnprintf(testbuf, 0, format, argp);
-	va_end(argp);
-	if (char_cnt_without_zero < 0) {
-		va_end(argp_copy);
-		return internal_dc_strdup("ErrFmt");
-	}
-
-	buf = malloc(char_cnt_without_zero+2 /* +1 would be enough, however, protect against off-by-one-errors */);
-	if (buf==NULL) {
-		va_end(argp_copy);
-		return internal_dc_strdup("ErrMem");
-	}
-
-	vsnprintf(buf, char_cnt_without_zero+1, format, argp_copy);
-	va_end(argp_copy);
-	return buf;
-}

misc.h

@@ -1 +0,0 @@
-char* dc_mprintf                 (const char* format, ...); /* The result must be free()'d. */

python/src/deltachat/account.py

@@ -50,9 +50,8 @@ class Account(object):
         self._configkeys = self.get_config("sys.config_keys").split()
         self._imex_completed = threading.Event()
 
-    # XXX this can cause "illegal instructions" at test ends so we omit it for now
-    # def __del__(self):
-    #    self.shutdown()
+    def __del__(self):
+        self.shutdown()
 
     def _check_config_key(self, name):
         if name not in self._configkeys:
@@ -397,7 +396,8 @@ class Account(object):
     def shutdown(self, wait=True):
         """ stop threads and close and remove underlying dc_context and callbacks. """
         if hasattr(self, "_dc_context") and hasattr(self, "_threads"):
-            self.stop_threads(wait=False)  # to interrupt idle and tell python threads to stop
+            # print("SHUTDOWN", self)
+            self.stop_threads(wait=False)
             lib.dc_close(self._dc_context)
             self.stop_threads(wait=wait)  # to wait for threads
             deltachat.clear_context_callback(self._dc_context)

python/src/deltachat/chatting.py

@@ -305,7 +305,6 @@ class Chat(object):
     def get_contacts(self):
         """ get all contacts for this chat.
         :params: contact object.
-        :raises ValueError: if contact could not be added
         :returns: list of :class:`deltachat.chatting.Contact` objects for this chat
 
         """

python/src/deltachat/const.py

@@ -8,6 +8,9 @@ from os.path import join as joinpath
 # this works well when you in a git-checkout
 # run "python deltachat/const.py" to regenerate events
 # begin const generated
+DC_PROVIDER_STATUS_OK = 1
+DC_PROVIDER_STATUS_PREPARATION = 2
+DC_PROVIDER_STATUS_BROKEN = 3
 DC_GCL_ARCHIVED_ONLY = 0x01
 DC_GCL_NO_SPECIALS = 0x02
 DC_GCL_ADD_ALLDONE_HINT = 0x04
@@ -84,7 +87,8 @@ DC_EVENT_IS_OFFLINE = 2081
 
 
 def read_event_defines(f):
-    rex = re.compile(r'#define\s+((?:DC_EVENT_|DC_QR|DC_MSG|DC_STATE_|DC_CONTACT_ID_|DC_GCL|DC_CHAT)\S+)\s+([x\d]+).*')
+    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)
         if m:

python/src/deltachat/message.py

@@ -110,7 +110,13 @@ class Message(object):
 
     def continue_key_transfer(self, setup_code):
         """ extract key and use it as primary key for this account. """
-        lib.dc_continue_key_transfer(self._dc_context, self.id, as_dc_charpointer(setup_code))
+        res = lib.dc_continue_key_transfer(
+                self._dc_context,
+                self.id,
+                as_dc_charpointer(setup_code)
+        )
+        if res == 0:
+            raise ValueError("could not decrypt")
 
     @props.with_doc
     def time_sent(self):

python/src/deltachat/provider.py

@@ -0,0 +1,67 @@
+"""Provider info class."""
+
+from .capi import ffi, lib
+from .cutil import as_dc_charpointer, from_dc_charpointer
+
+
+class ProviderNotFoundError(Exception):
+    """The provider information was not found."""
+
+
+class Provider(object):
+    """Provider information.
+
+    :param domain: The domain to get the provider info for, this is
+    normally the part following the `@` of the domain.
+    """
+
+    def __init__(self, domain):
+        provider = ffi.gc(
+            lib.dc_provider_new_from_domain(as_dc_charpointer(domain)),
+            lib.dc_provider_unref,
+        )
+        if provider == ffi.NULL:
+            raise ProviderNotFoundError("Provider not found")
+        self._provider = provider
+
+    @classmethod
+    def from_email(cls, email):
+        """Create provider info from an email address.
+
+        :param email: Email address to get provider info for.
+        """
+        return cls(email.split('@')[-1])
+
+    @property
+    def overview_page(self):
+        """URL to the overview page of the provider on providers.delta.chat."""
+        return from_dc_charpointer(
+            lib.dc_provider_get_overview_page(self._provider))
+
+    @property
+    def name(self):
+        """The name of the provider."""
+        return from_dc_charpointer(lib.dc_provider_get_name(self._provider))
+
+    @property
+    def markdown(self):
+        """Content of the information page, formatted as markdown."""
+        return from_dc_charpointer(
+            lib.dc_provider_get_markdown(self._provider))
+
+    @property
+    def status_date(self):
+        """The date the provider info was last updated, as a string."""
+        return from_dc_charpointer(
+            lib.dc_provider_get_status_date(self._provider))
+
+    @property
+    def status(self):
+        """The status of the provider information.
+
+        This is one of the
+        :attr:`deltachat.const.DC_PROVIDER_STATUS_OK`,
+        :attr:`deltachat.const.DC_PROVIDER_STATUS_PREPARATION` or
+        :attr:`deltachat.const.DC_PROVIDER_STATUS_BROKEN` constants.
+        """
+        return lib.dc_provider_get_status(self._provider)

python/tests/conftest.py

@@ -24,17 +24,6 @@ def pytest_configure(config):
             config.option.liveconfig = cfg
 
 
-@pytest.hookimpl(trylast=True)
-def pytest_runtest_call(item):
-    # perform early finalization because we otherwise get cloberred
-    # output from concurrent threads printing between execution
-    # of the test function and the teardown phase of that test function
-    if "acfactory" in item.funcargs:
-        print("*"*30, "finalizing", "*"*30)
-        acfactory = item.funcargs["acfactory"]
-        acfactory.finalize()
-
-
 def pytest_report_header(config, startdir):
     summary = []
 
@@ -136,13 +125,17 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig):
                 fin = self._finalizers.pop()
                 fin()
 
+        def make_account(self, path, logid):
+            ac = Account(path, logid=logid)
+            self._finalizers.append(ac.shutdown)
+            return ac
+
         def get_unconfigured_account(self):
             self.offline_count += 1
             tmpdb = tmpdir.join("offlinedb%d" % self.offline_count)
-            ac = Account(tmpdb.strpath, logid="ac{}".format(self.offline_count))
+            ac = self.make_account(tmpdb.strpath, logid="ac{}".format(self.offline_count))
             ac._evlogger.init_time = self.init_time
             ac._evlogger.set_timeout(2)
-            self._finalizers.append(ac.shutdown)
             return ac
 
         def get_configured_offline_account(self):
@@ -165,26 +158,35 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig):
             if "e2ee_enabled" not in configdict:
                 configdict["e2ee_enabled"] = "1"
             tmpdb = tmpdir.join("livedb%d" % self.live_count)
-            ac = Account(tmpdb.strpath, logid="ac{}".format(self.live_count))
+            ac = self.make_account(tmpdb.strpath, logid="ac{}".format(self.live_count))
             ac._evlogger.init_time = self.init_time
             ac._evlogger.set_timeout(30)
             ac.configure(**configdict)
             ac.start_threads()
-            self._finalizers.append(ac.shutdown)
             return ac
 
+        def get_two_online_accounts(self):
+            ac1 = self.get_online_configuring_account()
+            ac2 = self.get_online_configuring_account()
+            wait_successful_IMAP_SMTP_connection(ac1)
+            wait_configuration_progress(ac1, 1000)
+            wait_successful_IMAP_SMTP_connection(ac2)
+            wait_configuration_progress(ac2, 1000)
+            return ac1, ac2
+
         def clone_online_account(self, account):
             self.live_count += 1
             tmpdb = tmpdir.join("livedb%d" % self.live_count)
-            ac = Account(tmpdb.strpath, logid="ac{}".format(self.live_count))
+            ac = self.make_account(tmpdb.strpath, logid="ac{}".format(self.live_count))
             ac._evlogger.init_time = self.init_time
             ac._evlogger.set_timeout(30)
             ac.configure(addr=account.get_config("addr"), mail_pw=account.get_config("mail_pw"))
             ac.start_threads()
-            self._finalizers.append(ac.shutdown)
             return ac
 
-    return AccountMaker()
+    am = AccountMaker()
+    request.addfinalizer(am.finalize)
+    return am
 
 
 @pytest.fixture

python/tests/test_account.py

@@ -334,10 +334,11 @@ class TestOfflineChat:
 
 
 class TestOnlineAccount:
-    def test_one_account_init(self, acfactory):
-        ac1 = acfactory.get_online_configuring_account()
-        wait_successful_IMAP_SMTP_connection(ac1)
-        wait_configuration_progress(ac1, 1000)
+    def get_chat(self, ac1, ac2):
+        c2 = ac1.create_contact(email=ac2.get_config("addr"))
+        chat = ac1.create_chat_by_contact(c2)
+        assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
+        return chat
 
     def test_one_account_send(self, acfactory):
         ac1 = acfactory.get_online_configuring_account()
@@ -353,15 +354,8 @@ class TestOnlineAccount:
         assert ev[1] == msg_out.id
 
     def test_two_accounts_send_receive(self, acfactory):
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        c2 = ac1.create_contact(email=ac2.get_config("addr"))
-        chat = ac1.create_chat_by_contact(c2)
-        assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
-        wait_successful_IMAP_SMTP_connection(ac1)
-        wait_configuration_progress(ac1, 1000)
-        wait_successful_IMAP_SMTP_connection(ac2)
-        wait_configuration_progress(ac2, 1000)
+        ac1, ac2 = acfactory.get_two_online_accounts()
+        chat = self.get_chat(ac1, ac2)
 
         msg_out = chat.send_text("message1")
 
@@ -372,15 +366,8 @@ class TestOnlineAccount:
         assert msg_in.text == "message1"
 
     def test_forward_messages(self, acfactory):
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        c2 = ac1.create_contact(email=ac2.get_config("addr"))
-        chat = ac1.create_chat_by_contact(c2)
-        assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
-        wait_successful_IMAP_SMTP_connection(ac1)
-        wait_configuration_progress(ac1, 1000)
-        wait_successful_IMAP_SMTP_connection(ac2)
-        wait_configuration_progress(ac2, 1000)
+        ac1, ac2 = acfactory.get_two_online_accounts()
+        chat = self.get_chat(ac1, ac2)
 
         msg_out = chat.send_text("message2")
 
@@ -404,15 +391,10 @@ class TestOnlineAccount:
         assert not chat3.get_messages()
 
     def test_send_and_receive_message(self, acfactory, lp):
-        lp.sec("starting accounts, waiting for configuration")
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        c2 = ac1.create_contact(email=ac2.get_config("addr"))
-        chat = ac1.create_chat_by_contact(c2)
-        assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
+        ac1, ac2 = acfactory.get_two_online_accounts()
 
-        wait_configuration_progress(ac1, 1000)
-        wait_configuration_progress(ac2, 1000)
+        lp.sec("ac1: create chat with ac2")
+        chat = self.get_chat(ac1, ac2)
 
         lp.sec("sending text message from ac1 to ac2")
         msg_out = chat.send_text("message1")
@@ -454,15 +436,10 @@ class TestOnlineAccount:
         assert msg_out.is_out_mdn_received()
 
     def test_send_and_receive_will_encrypt_decrypt(self, acfactory, lp):
-        lp.sec("starting accounts, waiting for configuration")
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        c2 = ac1.create_contact(email=ac2.get_config("addr"))
-        chat = ac1.create_chat_by_contact(c2)
-        assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
+        ac1, ac2 = acfactory.get_two_online_accounts()
 
-        wait_configuration_progress(ac1, 1000)
-        wait_configuration_progress(ac2, 1000)
+        lp.sec("ac1: create chat with ac2")
+        chat = self.get_chat(ac1, ac2)
 
         lp.sec("sending text message from ac1 to ac2")
         msg_out = chat.send_text("message1")
@@ -485,14 +462,12 @@ class TestOnlineAccount:
         assert msg_back.text == "message-back"
 
     def test_saved_mime_on_received_message(self, acfactory, lp):
-        lp.sec("starting accounts, waiting for configuration")
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
+        ac1, ac2 = acfactory.get_two_online_accounts()
+
+        lp.sec("configure ac2 to save mime headers, create ac1/ac2 chat")
         ac2.set_config("save_mime_headers", "1")
-        c2 = ac1.create_contact(email=ac2.get_config("addr"))
-        chat = ac1.create_chat_by_contact(c2)
-        wait_configuration_progress(ac1, 1000)
-        wait_configuration_progress(ac2, 1000)
+        chat = self.get_chat(ac1, ac2)
+
         lp.sec("sending text message from ac1 to ac2")
         msg_out = chat.send_text("message1")
         ac1._evlogger.get_matching("DC_EVENT_MSG_DELIVERED")
@@ -506,14 +481,8 @@ class TestOnlineAccount:
         assert mime.get_all("Received")
 
     def test_send_and_receive_image(self, acfactory, lp, data):
-        lp.sec("starting accounts, waiting for configuration")
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        c2 = ac1.create_contact(email=ac2.get_config("addr"))
-        chat = ac1.create_chat_by_contact(c2)
-
-        wait_configuration_progress(ac1, 1000)
-        wait_configuration_progress(ac2, 1000)
+        ac1, ac2 = acfactory.get_two_online_accounts()
+        chat = self.get_chat(ac1, ac2)
 
         lp.sec("sending image message from ac1 to ac2")
         path = data.get_path("d.png")
@@ -533,13 +502,13 @@ class TestOnlineAccount:
         assert os.stat(msg_in.filename).st_size == os.stat(path).st_size
 
     def test_import_export_online(self, acfactory, tmpdir):
-        backupdir = tmpdir.mkdir("backup")
         ac1 = acfactory.get_online_configuring_account()
         wait_configuration_progress(ac1, 1000)
 
         contact1 = ac1.create_contact("some1@hello.com", name="some1")
         chat = ac1.create_chat_by_contact(contact1)
         chat.send_text("msg1")
+        backupdir = tmpdir.mkdir("backup")
         path = ac1.export_to_dir(backupdir.strpath)
         assert os.path.exists(path)
 
@@ -568,16 +537,16 @@ class TestOnlineAccount:
         ev = ac2._evlogger.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
         msg = ac2.get_message_by_id(ev[2])
         assert msg.is_setup_message()
+        # first try a bad setup code
+        with pytest.raises(ValueError):
+            msg.continue_key_transfer(str(reversed(setup_code)))
         print("*************** Incoming ASM File at: ", msg.filename)
         print("*************** Setup Code: ", setup_code)
         msg.continue_key_transfer(setup_code)
         assert ac1.get_info()["fingerprint"] == ac2.get_info()["fingerprint"]
 
     def test_qr_setup_contact(self, acfactory, lp):
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        wait_configuration_progress(ac2, 1000)
-        wait_configuration_progress(ac1, 1000)
+        ac1, ac2 = acfactory.get_two_online_accounts()
         lp.sec("ac1: create QR code and let ac2 scan it, starting the securejoin")
         qr = ac1.get_setup_contact_qr()
         lp.sec("ac2: start QR-code based setup contact protocol")
@@ -586,12 +555,8 @@ class TestOnlineAccount:
         wait_securejoin_inviter_progress(ac1, 1000)
 
     def test_qr_join_chat(self, acfactory, lp):
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        wait_configuration_progress(ac2, 1000)
-        wait_configuration_progress(ac1, 1000)
+        ac1, ac2 = acfactory.get_two_online_accounts()
         lp.sec("ac1: create QR code and let ac2 scan it, starting the securejoin")
-
         chat = ac1.create_group_chat("hello")
         qr = chat.get_join_qr()
         lp.sec("ac2: start QR-code based join-group protocol")
@@ -600,10 +565,7 @@ class TestOnlineAccount:
         wait_securejoin_inviter_progress(ac1, 1000)
 
     def test_set_get_profile_image(self, acfactory, data, lp):
-        ac1 = acfactory.get_online_configuring_account()
-        ac2 = acfactory.get_online_configuring_account()
-        wait_configuration_progress(ac2, 1000)
-        wait_configuration_progress(ac1, 1000)
+        ac1, ac2 = acfactory.get_two_online_accounts()
 
         lp.sec("create unpromoted group chat")
         chat = ac1.create_group_chat("hello")

python/tests/test_lowlevel.py

@@ -1,5 +1,5 @@
 from __future__ import print_function
-from deltachat import capi, const, set_context_callback, clear_context_callback
+from deltachat import capi, cutil, const, set_context_callback, clear_context_callback
 from deltachat.capi import ffi
 from deltachat.capi import lib
 from deltachat.account import EventLogger
@@ -83,3 +83,18 @@ def test_markseen_invalid_message_ids(acfactory):
     msg_ids = [9]
     lib.dc_markseen_msgs(ac1._dc_context, msg_ids, len(msg_ids))
     ac1._evlogger.ensure_event_not_queued("DC_EVENT_WARNING|DC_EVENT_ERROR")
+
+
+def test_provider_info():
+    provider = lib.dc_provider_new_from_email(cutil.as_dc_charpointer("ex@example.com"))
+    assert cutil.from_dc_charpointer(
+        lib.dc_provider_get_overview_page(provider)
+    ) == "https://providers.delta.chat/example.com"
+    assert cutil.from_dc_charpointer(lib.dc_provider_get_name(provider)) == "Example"
+    assert cutil.from_dc_charpointer(lib.dc_provider_get_markdown(provider)) == "\n..."
+    assert cutil.from_dc_charpointer(lib.dc_provider_get_status_date(provider)) == "2018-09"
+    assert lib.dc_provider_get_status(provider) == const.DC_PROVIDER_STATUS_PREPARATION
+
+
+def test_provider_info_none():
+    assert lib.dc_provider_new_from_email(cutil.as_dc_charpointer("email@unexistent.no")) == ffi.NULL

python/tests/test_provider_info.py

@@ -0,0 +1,27 @@
+import pytest
+
+from deltachat import const
+from deltachat import provider
+
+
+def test_provider_info_from_email():
+    example = provider.Provider.from_email("email@example.com")
+    assert example.overview_page == "https://providers.delta.chat/example.com"
+    assert example.name == "Example"
+    assert example.markdown == "\n..."
+    assert example.status_date == "2018-09"
+    assert example.status == const.DC_PROVIDER_STATUS_PREPARATION
+
+
+def test_provider_info_from_domain():
+    example = provider.Provider("example.com")
+    assert example.overview_page == "https://providers.delta.chat/example.com"
+    assert example.name == "Example"
+    assert example.markdown == "\n..."
+    assert example.status_date == "2018-09"
+    assert example.status == const.DC_PROVIDER_STATUS_PREPARATION
+
+
+def test_provider_info_none():
+    with pytest.raises(provider.ProviderNotFoundError):
+        provider.Provider.from_email("email@unexistent.no")

spec.md

@@ -0,0 +1,372 @@
+# Chat-over-Email specification
+
+Version 0.19.0
+
+This document describes how emails can be used
+to implement typical messenger functions
+while staying compatible to existing MUAs.
+
+- [Encryption](#encryption)
+- [Outgoing messages](#outgoing-messages)
+- [Incoming messages](#incoming-messages)
+- [Forwarded messages](#forwarded-messages)
+- [Groups](#groups)
+    - [Outgoing group messages](#outgoing-group-messages)
+    - [Incoming group messages](#incoming-group-messages)
+    - [Add and remove members](#add-and-remove-members)
+    - [Change group name](#change-group-name)
+    - [Set group image](#set-group-image)
+- [Set profile image](#set-profile-image)
+- [Miscellaneous](#miscellaneous)
+
+
+# Encryption
+
+Messages SHOULD be encrypted by the
+[Autocrypt](https://autocrypt.org/level1.html) standard;
+`prefer-encrypt=mutual` MAY be set by default.
+
+Meta data (at least the subject and all chat-headers) SHOULD be encrypted
+by the [Memoryhole](https://github.com/autocrypt/memoryhole) standard.
+If Memoryhole is not used,
+the subject of encrypted messages SHOULD be replaced by the string
+`Chat: Encrypted message` where the part after the colon MAY be localized.
+
+
+# Outgoing messages
+
+Messengers MUST add a `Chat-Version: 1.0` header to outgoing messages.
+For filtering and smart appearance of the messages in normal MUAs,
+the `Subject` header SHOULD start with the characters `Chat:`
+and SHOULD be an excerpt of the message.
+Replies to messages MAY follow the typical `Re:`-format.
+
+The body MAY contain text which MUST have the content type `text/plain`
+or `mulipart/alternative` containing `text/plain`.
+
+The text MAY be divided into a user-text-part and a footer-part using the
+line `-- ` (minus, minus, space, lineend).
+
+The user-text-part MUST contain only user generated content.
+User generated content are eg. texts a user has actually typed
+or pasted or forwarded from another user.
+Full quotes, footers or sth. like that MUST NOT go to the user-text-part.
+
+    From: sender@domain
+    To: rcpt@domain
+    Chat-Version: 1.0
+    Content-Type: text/plain
+    Subject: Chat: Hello ...
+
+    Hello world!
+
+
+# Incoming messages
+
+The `Chat-Version` header MAY be used
+to detect if a messages comes from a compatible messenger.
+
+The `Subject` header MUST NOT be used
+to detect compatible messengers, groups or whatever.
+
+Messenger SHOULD show the `Subject`
+if the message comes from a normal MUA together with the email-body.
+The email-body SHOULD be converted
+to plain text, full-quotes and similar regions SHOULD be cut.
+
+Attachments SHOULD be shown where possible.
+If an attachment cannot be shown, a non-distracting warning SHOULD be printed.
+
+
+# Forwarded messages
+
+Forwarded messages are outgoing messages that contain a forwarded-header
+before the user generated content.
+
+The forwarded header MUST contain two lines: 
+The first line contains the text
+`---------- Forwarded message ----------`
+(10 minus, space, text `Forwarded message`, space, 10 minus). 
+The second line starts with `From: ` followed by the original sender
+which SHOULD be anonymized or just a placeholder.
+
+    From: sender@domain
+    To: rcpt@domain
+    Chat-Version: 1.0
+    Content-Type: text/plain
+    Subject: Chat: Forwarded message
+
+    ---------- Forwarded message ----------
+    From: Messenger
+
+    Hello world!
+
+Incoming forwarded messages are detected by the header.
+The messenger SHOULD mark these messages in a way that
+it becomes obvious that the message is not created by the sender.
+Note that most messengers do not show the original sender of forwarded messages
+but MUAs typically expose the sender in the UI.
+
+
+# Groups
+
+Groups are chats with usually more than one recipient,
+each defined by an email-address.
+The sender plus the recipients are the group members.
+
+To allow different groups with the same members,
+groups are identified by a group-id.
+The group-id MUST be created only from the characters
+`0`-`9`, `A`-`Z`, `a`-`z` `_` and `-`.
+
+Groups MUST have a group-name.
+The group-name is any non-zero-length UTF-8 string.
+
+Groups MAY have a group-image.
+
+
+## Outgoing groups messages
+
+All group members MUST be added to the `From`/`To` headers.
+The group-id MUST be written to the `Chat-Group-ID` header.
+The group-name MUST be written to `Chat-Group-Name` header
+(the forced presence of this header makes it easier
+to join a group chat on a second device any time).
+
+The `Subject` header of outgoing group messages
+SHOULD start with the characters `Chat:`
+followed by the group-name and a colon followed by an excerpt of the message.
+
+To identify the group-id on replies from normal MUAs,
+the group-id MUST also be added to the message-id of outgoing messages.
+The message-id MUST have the format `Gr.<group-id>.<unique data>`.
+
+    From: member1@domain
+    To: member2@domain, member3@domain
+    Chat-Version: 1.0
+    Chat-Group-ID: 1234xyZ
+    Chat-Group-Name: My Group
+    Message-ID: Gr.1234xyZ.0001@domain
+    Subject: Chat: My Group: Hello group ...
+
+    Hello group - this group contains three members
+
+Messengers adding the member list in the form `Name <email-address>`
+MUST take care only to spread the names authorized by the contacts themselves.
+Otherwise, names as _Daddy_ or _Honey_ may be spread
+(this issue is also true for normal MUAs, however,
+for more contact- and chat-centralized apps
+such situations happen more frequently).
+
+
+## Incoming group messages
+
+The messenger MUST search incoming messages for the group-id
+in the following headers: `Chat-Group-ID`,
+`Message-ID`, `In-Reply-To` and `References` (in this order).
+
+If the messenger finds a valid and existent group-id,
+the message SHOULD be assigned to the given group.
+If the messenger finds a valid but not existent group-id,
+the messenger MAY create a new group.
+If no group-id is found,
+the message MAY be assigned
+to a normal single-user chat with the email-address given in `From`.
+
+
+## Add and remove members
+
+Messenger clients MUST construct the member list
+from the `From`/`To` headers only on the first group message
+or if they see a `Chat-Group-Member-Added`
+or `Chat-Group-Member-Removed` action header.
+Both headers MUST have the email-address
+of the added or removed member as the value.
+Messenger clients MUST NOT construct the member list
+on other group messages
+(this is to avoid accidentally altered To-lists in normal MUAs;
+the user does not expect adding a user to a _message_
+will also add him to the _group_ "forever").
+
+The messenger SHOULD send an explicit mail for each added or removed member.
+The body of the message SHOULD contain
+a localized description about what happened
+and the message SHOULD appear as a message or action from the sender.
+
+    From: member1@domain
+    To: member2@domain, member3@domain, member4@domain
+    Chat-Version: 1.0
+    Chat-Group-ID: 1234xyZ
+    Chat-Group-Name: My Group
+    Chat-Group-Member-Added: member4@domain
+    Message-ID: Gr.1234xyZ.0002@domain
+    Subject: Chat: My Group: Hello, ...
+
+    Hello, I've added member4@domain to our group.  Now we have 4 members.
+
+To remove a member:
+
+    From: member1@domain
+    To: member2@domain, member3@domain
+    Chat-Version: 1.0
+    Chat-Group-ID: 1234xyZ
+    Chat-Group-Name: My Group
+    Chat-Group-Member-Removed: member4@domain
+    Message-ID: Gr.1234xyZ.0003@domain
+    Subject: Chat: My Group: Hello, ...
+
+    Hello, I've removed member4@domain from our group.  Now we have 3 members.
+
+
+## Change group name
+
+To change the group-name,
+the messenger MUST send the action header `Chat-Group-Name-Changed`
+with the value set to the old group name to all group members.
+The new group name goes to the header `Chat-Group-Name`.
+
+The messenger SHOULD send an explicit mail for each name change.
+The body of the message SHOULD contain
+a localized description about what happened
+and the message SHOULD appear as a message or action from the sender.
+
+    From: member1@domain
+    To: member2@domain, member3@domain
+    Chat-Version: 1.0
+    Chat-Group-ID: 1234xyZ
+    Chat-Group-Name: Our Group
+    Chat-Group-Name-Changed: My Group
+    Message-ID: Gr.1234xyZ.0004@domain
+    Subject: Chat: Our Group: Hello, ...
+
+    Hello, I've changed the group name from "My Group" to "Our Group".
+
+
+## Set group image
+
+A group MAY have a group-image.
+To change or set the group-image,
+the messenger MUST attach an image file to a message
+and MUST add the header `Chat-Group-Image`
+with the value set to the image name.
+
+To remove the group-image,
+the messenger MUST add the header `Chat-Group-Image: 0`.
+
+The messenger SHOULD send an explicit mail for each group image change.
+The body of the message SHOULD contain
+a localized description about what happened
+and the message SHOULD appear as a message or action from the sender.
+
+
+    From: member1@domain
+    To: member2@domain, member3@domain
+    Chat-Version: 1.0
+    Chat-Group-ID: 1234xyZ
+    Chat-Group-Name: Our Group
+    Chat-Group-Image: image.jpg
+    Message-ID: Gr.1234xyZ.0005@domain
+    Subject: Chat: Our Group: Hello, ...
+    Content-Type: multipart/mixed; boundary="==break=="
+
+    --==break==
+    Content-Type: text/plain
+
+    Hello, I've changed the group image.
+    --==break==
+    Content-Type: image/jpeg
+    Content-Disposition: attachment; filename="image.jpg"
+
+    /9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBw ...
+    --==break==--
+
+The image format SHOULD be image/jpeg or image/png.
+To save data, it is RECOMMENDED
+to add a `Chat-Group-Image` only on image changes.
+
+
+# Set profile image
+
+A user MAY have a profile-image that MAY be spread to his contacts.
+To change or set the profile-image,
+the messenger MUST attach an image file to a message
+and MUST add the header `Chat-Profile-Image`
+with the value set to the image name.
+
+To remove the profile-image,
+the messenger MUST add the header `Chat-Profile-Image: 0`.
+
+To spread the image,
+the messenger MAY send the profile image
+together with the next mail to a given contact
+(to do this only once,
+the messenger has to keep a `profile_image_update_state` somewhere).
+Alternatively, the messenger MAY send an explicit mail
+for each profile-image change to all contacts using a compatible messenger.
+The messenger SHOULD NOT send an explicit mail to normal MUAs.
+
+    From: sender@domain
+    To: rcpt@domain
+    Chat-Version: 1.0
+    Chat-Profile-Image: photo.jpg
+    Subject: Chat: Hello, ...
+    Content-Type: multipart/mixed; boundary="==break=="
+
+    --==break==
+    Content-Type: text/plain
+
+    Hello, I've changed my profile image.
+    --==break==
+    Content-Type: image/jpeg
+    Content-Disposition: attachment; filename="photo.jpg"
+
+    AKCgkJi3j4l5kjoldfUAKCgkJi3j4lldfHjgWICwgIEBQYFBA ...
+    --==break==--
+
+The image format SHOULD be image/jpeg or image/png.
+Note that `Chat-Profile-Image` may appear together with all other headers,
+eg. there may be a `Chat-Profile-Image` and a `Chat-Group-Image` header
+in the same message.
+To save data, it is RECOMMENDED to add a `Chat-Profile-Image` header
+only on image changes.
+
+
+# Miscellaneous
+
+Messengers SHOULD use the header `Chat-Predecessor`
+instead of `In-Reply-To` as the latter one results
+in infinite threads on typical MUAs.
+
+Messengers SHOULD add a `Chat-Voice-message: 1` header
+if an attached audio file is a voice message.
+
+Messengers MAY add a `Chat-Duration` header
+to specify the duration of attached audio or video files.
+The value MUST be the duration in milliseconds.
+This allows the receiver to show the time without knowing the file format.
+
+    Chat-Predecessor: foo123@domain
+    Chat-Voice-Message: 1
+    Chat-Duration: 10000
+
+Messengers MAY send and receive Message Disposition Notifications
+(MDNs, [RFC 8098](https://tools.ietf.org/html/rfc8098),
+[RFC 3503](https://tools.ietf.org/html/rfc3503))
+using the `Chat-Disposition-Notification-To` header
+instead of the `Disposition-Notification-To`
+(which unfortunately forces many other MUAs
+to send weird mails not following any standard).
+
+
+## Sync messages
+
+If some action is required by a message header,
+the action should only be performed if the _effective date_ is newer
+than the date the last action was performed.
+
+We define the effective date of a message
+as the sending time of the message as indicated by its Date header,
+or the time of first receipt if that date is in the future or unavailable.
+
+
+Copyright © 2017-2019 Delta Chat contributors.

src/chat.rs

@@ -7,6 +7,7 @@ use crate::config::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
+use crate::dc_mimeparser::SystemMessage;
 use crate::dc_tools::*;
 use crate::error::Error;
 use crate::events::Event;
@@ -1669,7 +1670,8 @@ pub fn set_chat_profile_image(
         if chat.update_param(context).is_ok() {
             if chat.is_promoted() {
                 let mut msg = dc_msg_new_untyped();
-                msg.param.set_int(Param::Cmd, DC_CMD_GROUPIMAGE_CHANGED);
+                msg.param
+                    .set_int(Param::Cmd, SystemMessage::GroupImageChanged as i32);
                 msg.type_0 = Viewtype::Text;
                 msg.text = Some(context.stock_system_msg(
                     if new_image_rel == "" {

src/constants.rs

@@ -314,12 +314,3 @@ pub enum KeyType {
     Public = 0,
     Private = 1,
 }
-
-pub const DC_CMD_GROUPNAME_CHANGED: libc::c_int = 2;
-pub const DC_CMD_GROUPIMAGE_CHANGED: libc::c_int = 3;
-pub const DC_CMD_MEMBER_ADDED_TO_GROUP: libc::c_int = 4;
-pub const DC_CMD_MEMBER_REMOVED_FROM_GROUP: libc::c_int = 5;
-pub const DC_CMD_AUTOCRYPT_SETUP_MESSAGE: libc::c_int = 6;
-pub const DC_CMD_SECUREJOIN_MESSAGE: libc::c_int = 7;
-pub const DC_CMD_LOCATION_STREAMING_ENABLED: libc::c_int = 8;
-pub const DC_CMD_LOCATION_ONLY: libc::c_int = 9;

src/context.rs

@@ -50,7 +50,7 @@ pub struct Context {
     pub smtp_state: Arc<(Mutex<SmtpState>, Condvar)>,
     pub oauth2_critical: Arc<Mutex<()>>,
     #[debug_stub = "Callback"]
-    pub cb: Box<ContextCallback>,
+    cb: Box<ContextCallback>,
     pub os_name: Option<String>,
     pub cmdline_sel_chat_id: Arc<RwLock<u32>>,
     pub bob: Arc<RwLock<BobStatus>>,
@@ -438,6 +438,13 @@ mod tests {
         assert!(res.is_err());
     }
 
+    #[test]
+    fn test_get_fresh_msgs() {
+        let t = dummy_context();
+        let fresh = t.ctx.get_fresh_msgs();
+        assert!(fresh.is_empty())
+    }
+
     #[test]
     fn test_blobdir_exists() {
         let tmp = tempfile::tempdir().unwrap();
@@ -468,6 +475,15 @@ mod tests {
         assert!(dbfile2.is_file());
     }
 
+    #[test]
+    fn test_with_empty_blobdir() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dbfile = tmp.path().join("db.sqlite");
+        let blobdir = PathBuf::new();
+        let res = Context::with_blobdir(Box::new(|_, _| 0), "FakeOS".into(), dbfile, blobdir);
+        assert!(res.is_err());
+    }
+
     #[test]
     fn test_with_blobdir_not_exists() {
         let tmp = tempfile::tempdir().unwrap();

src/dc_dehtml.rs

@@ -165,3 +165,28 @@ fn dehtml_starttag_cb<B: std::io::BufRead>(
         _ => {}
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_dc_dehtml() {
+        let cases = vec![
+            (
+                "<a href='https://example.com'> Foo </a>",
+                "[ Foo ](https://example.com)",
+            ),
+            ("<img href='/foo.png'>", ""),
+            ("<b> bar </b>", "* bar *"),
+            ("<b> bar <i> foo", "* bar _ foo"),
+            ("&amp; bar", "& bar"),
+            // Note missing '
+            ("<a href='/foo.png>Hi</a> ", ""),
+            ("", ""),
+        ];
+        for (input, output) in cases {
+            assert_eq!(dc_dehtml(input), output);
+        }
+    }
+}

src/dc_imex.rs

@@ -101,7 +101,6 @@ pub unsafe fn dc_imex_has_backup(
 }
 
 pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
-    let mut setup_file_name: *mut libc::c_char = ptr::null_mut();
     let mut msg: Message;
     if !dc_alloc_ongoing(context) {
         return std::ptr::null_mut();
@@ -115,8 +114,7 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
         .unwrap()
         .shall_stop_ongoing
     {
-        if let Ok(setup_file_content) = dc_render_setup_file(context, &setup_code) {
-            let setup_file_content_c = CString::yolo(setup_file_content.as_str());
+        if let Ok(ref setup_file_content) = dc_render_setup_file(context, &setup_code) {
             /* encrypting may also take a while ... */
             if !context
                 .running_state
@@ -125,23 +123,14 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
                 .unwrap()
                 .shall_stop_ongoing
             {
-                setup_file_name = dc_get_fine_pathNfilename(
-                    context,
-                    b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
-                    b"autocrypt-setup-message.html\x00" as *const u8 as *const libc::c_char,
-                );
-                if !(setup_file_name.is_null()
-                    || 0 == dc_write_file(
-                        context,
-                        setup_file_name,
-                        setup_file_content_c.as_ptr() as *const libc::c_void,
-                        setup_file_content_c.as_bytes().len(),
-                    ))
-                {
+                let setup_file_name =
+                    dc_get_fine_path_filename(context, "$BLOBDIR", "autocrypt-setup-message.html");
+                if dc_write_file(context, &setup_file_name, setup_file_content.as_bytes()) {
                     if let Ok(chat_id) = chat::create_by_contact_id(context, 1) {
                         msg = dc_msg_new_untyped();
                         msg.type_0 = Viewtype::File;
-                        msg.param.set(Param::File, as_str(setup_file_name));
+                        msg.param
+                            .set(Param::File, setup_file_name.to_string_lossy());
 
                         msg.param
                             .set(Param::MimeType, "application/autocrypt-setup");
@@ -182,7 +171,6 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
             }
         }
     }
-    free(setup_file_name as *mut libc::c_void);
     dc_free_ongoing(context);
 
     setup_code.strdup()
@@ -208,8 +196,8 @@ pub fn dc_render_setup_file(context: &Context, passphrase: &str) -> Result<Strin
         _ => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
     };
     let private_key_asc = private_key.to_asc(ac_headers);
-    let encr = dc_pgp_symm_encrypt(&passphrase, private_key_asc.as_bytes())
-        .ok_or(format_err!("Failed to encrypt private key."))?;
+    let encr = dc_pgp_symm_encrypt(&passphrase, private_key_asc.as_bytes())?;
+
     let replacement = format!(
         concat!(
             "-----BEGIN PGP MESSAGE-----\r\n",
@@ -397,7 +385,7 @@ fn set_self_key(
 }
 
 pub unsafe fn dc_decrypt_setup_file(
-    _context: &Context,
+    context: &Context,
     passphrase: *const libc::c_char,
     filecontent: *const libc::c_char,
 ) -> *mut libc::c_char {
@@ -436,12 +424,17 @@ pub unsafe fn dc_decrypt_setup_file(
             || binary_bytes == 0)
         {
             /* decrypt symmetrically */
-            if let Some(plain) = dc_pgp_symm_decrypt(
+            match dc_pgp_symm_decrypt(
                 as_str(passphrase),
                 std::slice::from_raw_parts(binary as *const u8, binary_bytes),
             ) {
-                let payload_c = CString::new(plain).unwrap();
-                payload = strdup(payload_c.as_ptr());
+                Ok(plain) => {
+                    let payload_c = CString::new(plain).unwrap();
+                    payload = strdup(payload_c.as_ptr());
+                }
+                Err(err) => {
+                    error!(context, "Failed to decrypt message: {:?}", err);
+                }
             }
         }
     }
@@ -490,10 +483,9 @@ pub unsafe fn dc_normalize_setup_code(
 pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) {
     let mut ok_to_continue = true;
     let mut success: libc::c_int = 0;
-    let what: libc::c_int;
 
     if dc_alloc_ongoing(context) {
-        what = job.param.get_int(Param::Cmd).unwrap_or_default();
+        let what = job.param.get_int(Param::Cmd).unwrap_or_default();
         let param1_s = job.param.get(Param::Arg).unwrap_or_default();
         let param1 = CString::yolo(param1_s);
         let _param2 = CString::yolo(job.param.get(Param::Arg2).unwrap_or_default());
@@ -640,7 +632,7 @@ unsafe fn import_backup(context: &Context, backup_to_import: *const libc::c_char
                 }
 
                 let pathNfilename = context.get_blobdir().join(file_name);
-                if dc_write_file_safe(context, &pathNfilename, &file_blob) {
+                if dc_write_file(context, &pathNfilename, &file_blob) {
                     continue;
                 }
                 error!(
@@ -687,13 +679,8 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> bool {
     let res = chrono::NaiveDateTime::from_timestamp(now as i64, 0)
         .format("delta-chat-%Y-%m-%d.bak")
         .to_string();
-    let buffer = CString::yolo(res);
-    let dest_pathNfilename = dc_get_fine_pathNfilename(context, dir, buffer.as_ptr());
-    if dest_pathNfilename.is_null() {
-        error!(context, "Cannot get backup file name.",);
 
-        return success;
-    }
+    let dest_path_filename = dc_get_fine_path_filename(context, as_path(dir), res);
 
     sql::housekeeping(context);
 
@@ -704,15 +691,15 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> bool {
         context,
         "Backup \"{}\" to \"{}\".",
         context.get_dbfile().display(),
-        as_str(dest_pathNfilename),
+        dest_path_filename.display(),
     );
-    if dc_copy_file(context, context.get_dbfile(), as_path(dest_pathNfilename)) {
+    if dc_copy_file(context, context.get_dbfile(), &dest_path_filename) {
         context.sql.open(&context, &context.get_dbfile(), 0);
         closed = false;
         /* 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();
-        if sql.open(context, as_path(dest_pathNfilename), 0) {
+        if sql.open(context, &dest_path_filename, 0) {
             if !sql.table_exists("backup_blobs") {
                 if sql::execute(
                     context,
@@ -821,9 +808,7 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> bool {
                             .set_config_int(context, "backup_time", now as i32)
                             .is_ok()
                         {
-                            context.call_cb(Event::ImexFileWritten(
-                                as_path(dest_pathNfilename).to_path_buf(),
-                            ));
+                            context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
                             success = true;
                         }
                     }
@@ -841,9 +826,8 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> bool {
         context.sql.open(&context, &context.get_dbfile(), 0);
     }
     if 0 != delete_dest_file {
-        dc_delete_file(context, as_path(dest_pathNfilename));
+        dc_delete_file(context, &dest_path_filename);
     }
-    free(dest_pathNfilename as *mut libc::c_void);
 
     success
 }
@@ -860,10 +844,8 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) ->
     (currently, the last imported key is the standard key unless it contains the string "legacy" in its name) */
     let mut imported_cnt: libc::c_int = 0;
     let mut suffix: *mut libc::c_char = ptr::null_mut();
-    let mut path_plus_name: *mut libc::c_char = ptr::null_mut();
     let mut set_default: libc::c_int;
     let mut buf: *mut libc::c_char = ptr::null_mut();
-    let mut buf_bytes: libc::size_t = 0;
     // a pointer inside buf, MUST NOT be free()'d
     let mut private_key: *const libc::c_char;
     let mut buf2: *mut libc::c_char = ptr::null_mut();
@@ -886,25 +868,21 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) ->
                 {
                     continue;
                 }
-                free(path_plus_name as *mut libc::c_void);
-                path_plus_name = dc_mprintf(
-                    b"%s/%s\x00" as *const u8 as *const libc::c_char,
-                    dir_name,
-                    name_c.as_ptr(),
-                );
-                info!(context, "Checking: {}", as_str(path_plus_name));
-                free(buf as *mut libc::c_void);
+                let path_plus_name = dir.join(entry.file_name());
+                info!(context, "Checking: {}", path_plus_name.display());
+
+                free(buf.cast());
                 buf = ptr::null_mut();
-                if 0 == dc_read_file(
-                    context,
-                    path_plus_name,
-                    &mut buf as *mut *mut libc::c_char as *mut *mut libc::c_void,
-                    &mut buf_bytes,
-                ) || buf_bytes < 50
-                {
+
+                if let Some(buf_r) = dc_read_file_safe(context, &path_plus_name) {
+                    buf = buf_r.as_ptr() as *mut _;
+                    std::mem::forget(buf_r);
+                } else {
                     continue;
-                }
+                };
+
                 private_key = buf;
+
                 free(buf2 as *mut libc::c_void);
                 buf2 = dc_strdup(buf);
                 if dc_split_armored_data(
@@ -937,7 +915,7 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) ->
                     info!(
                         context,
                         "Treating \"{}\" as a legacy private key.",
-                        as_str(path_plus_name),
+                        path_plus_name.display(),
                     );
                     set_default = 0i32
                 }
@@ -963,7 +941,6 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) ->
     }
 
     free(suffix as *mut libc::c_void);
-    free(path_plus_name as *mut libc::c_void);
     free(buf as *mut libc::c_void);
     free(buf2 as *mut libc::c_void);
 
@@ -1026,38 +1003,31 @@ unsafe fn export_key_to_asc_file(
     is_default: libc::c_int,
 ) -> bool {
     let mut success = false;
-    let file_name;
-    if 0 != is_default {
-        file_name = dc_mprintf(
-            b"%s/%s-key-default.asc\x00" as *const u8 as *const libc::c_char,
-            dir,
-            if key.is_public() {
-                b"public\x00" as *const u8 as *const libc::c_char
-            } else {
-                b"private\x00" as *const u8 as *const libc::c_char
-            },
-        )
+    let dir = as_path(dir);
+
+    let file_name = if 0 != is_default {
+        let name = format!(
+            "{}-key-default.asc",
+            if key.is_public() { "public" } else { "private" },
+        );
+        dir.join(name)
     } else {
-        file_name = dc_mprintf(
-            b"%s/%s-key-%i.asc\x00" as *const u8 as *const libc::c_char,
-            dir,
-            if key.is_public() {
-                b"public\x00" as *const u8 as *const libc::c_char
-            } else {
-                b"private\x00" as *const u8 as *const libc::c_char
-            },
-            id,
-        )
-    }
-    info!(context, "Exporting key {}", as_str(file_name),);
-    dc_delete_file(context, as_path(file_name));
-    if !key.write_asc_to_file(as_path(file_name), context) {
-        error!(context, "Cannot write key to {}", as_str(file_name),);
+        let name = format!(
+            "{}-key-{}.asc",
+            if key.is_public() { "public" } else { "private" },
+            id
+        );
+        dir.join(name)
+    };
+    info!(context, "Exporting key {}", file_name.display());
+    dc_delete_file(context, &file_name);
+
+    if !key.write_asc_to_file(&file_name, context) {
+        error!(context, "Cannot write key to {}", file_name.display());
     } else {
-        context.call_cb(Event::ImexFileWritten(as_path(file_name).to_path_buf()));
+        context.call_cb(Event::ImexFileWritten(file_name.clone()));
         success = true;
     }
-    free(file_name as *mut libc::c_void);
 
     success
 }

src/dc_mimefactory.rs

@@ -1,4 +1,4 @@
-use std::ffi::CString;
+use std::path::Path;
 use std::ptr;
 
 use chrono::TimeZone;
@@ -16,6 +16,7 @@ use crate::chat::{self, Chat};
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::{get_version_str, Context};
+use crate::dc_mimeparser::SystemMessage;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
 use crate::e2ee::*;
@@ -31,7 +32,7 @@ use crate::x::*;
 pub struct dc_mimefactory_t<'a> {
     pub from_addr: *mut libc::c_char,
     pub from_displayname: *mut libc::c_char,
-    pub selfstatus: *mut libc::c_char,
+    pub selfstatus: Option<String>,
     pub recipients_names: *mut clist,
     pub recipients_addr: *mut clist,
     pub timestamp: i64,
@@ -56,7 +57,6 @@ impl<'a> Drop for dc_mimefactory_t<'a> {
         unsafe {
             free(self.from_addr as *mut libc::c_void);
             free(self.from_displayname as *mut libc::c_void);
-            free(self.selfstatus as *mut libc::c_void);
             free(self.rfc724_mid as *mut libc::c_void);
             if !self.recipients_names.is_null() {
                 clist_free_content(self.recipients_names);
@@ -94,7 +94,7 @@ pub unsafe fn dc_mimefactory_load_msg(
     let mut factory = dc_mimefactory_t {
         from_addr: ptr::null_mut(),
         from_displayname: ptr::null_mut(),
-        selfstatus: ptr::null_mut(),
+        selfstatus: None,
         recipients_names: clist_new(),
         recipients_addr: clist_new(),
         timestamp: 0,
@@ -170,10 +170,10 @@ pub unsafe fn dc_mimefactory_load_msg(
             )
             .unwrap();
 
-        let command = factory.msg.param.get_int(Param::Cmd).unwrap_or_default();
+        let command = factory.msg.param.get_cmd();
         let msg = &factory.msg;
 
-        if command == 5 {
+        if command == SystemMessage::MemberRemovedFromGroup {
             let email_to_remove = msg.param.get(Param::Arg).unwrap_or_default();
             let email_to_remove_c = email_to_remove.strdup();
 
@@ -197,8 +197,8 @@ pub unsafe fn dc_mimefactory_load_msg(
                 }
             }
         }
-        if command != 6
-            && command != 7
+        if command != SystemMessage::AutocryptSetupMessage
+            && command != SystemMessage::SecurejoinMessage
             && 0 != context
                 .sql
                 .get_config_int(context, "mdns_enabled")
@@ -252,14 +252,16 @@ unsafe fn load_from(factory: &mut dc_mimefactory_t) {
         .unwrap_or_default()
         .strdup();
 
-    factory.selfstatus = context
-        .sql
-        .get_config(context, "selfstatus")
-        .unwrap_or_default()
-        .strdup();
-    if factory.selfstatus.is_null() {
-        factory.selfstatus = factory.context.stock_str(StockMessage::StatusLine).strdup();
-    };
+    factory.selfstatus = context.sql.get_config(context, "selfstatus");
+
+    if factory.selfstatus.is_none() {
+        factory.selfstatus = Some(
+            factory
+                .context
+                .stock_str(StockMessage::StatusLine)
+                .to_string(),
+        );
+    }
 }
 
 pub unsafe fn dc_mimefactory_load_mdn<'a>(
@@ -282,7 +284,7 @@ pub unsafe fn dc_mimefactory_load_mdn<'a>(
     let mut factory = dc_mimefactory_t {
         from_addr: ptr::null_mut(),
         from_displayname: ptr::null_mut(),
-        selfstatus: ptr::null_mut(),
+        selfstatus: None,
         recipients_names: clist_new(),
         recipients_addr: clist_new(),
         timestamp: 0,
@@ -341,7 +343,6 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
     let mut message: *mut mailmime = ptr::null_mut();
     let mut message_text: *mut libc::c_char = ptr::null_mut();
     let mut message_text2: *mut libc::c_char = ptr::null_mut();
-    let mut subject_str: *mut libc::c_char = ptr::null_mut();
     let mut afwd_email: libc::c_int = 0;
     let mut col: libc::c_int = 0;
     let mut success = false;
@@ -368,7 +369,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
             from,
             mailimf_mailbox_new(
                 if !factory.from_displayname.is_null() {
-                    dc_encode_header_words(factory.from_displayname)
+                    dc_encode_header_words(as_str(factory.from_displayname))
                 } else {
                     ptr::null_mut()
                 },
@@ -402,7 +403,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                         MAILIMF_ADDRESS_MAILBOX as libc::c_int,
                         mailimf_mailbox_new(
                             if !name.is_null() {
-                                dc_encode_header_words(name)
+                                dc_encode_header_words(as_str(name))
                             } else {
                                 ptr::null_mut()
                             },
@@ -457,17 +458,12 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
             .as_ref()
             .map(|s| format!("/{}", s))
             .unwrap_or_default();
-        let os_part = CString::new(os_part).expect("String -> CString conversion failed");
-        let version = CString::yolo(get_version_str());
+        let version = get_version_str();
         mailimf_fields_add(
             imf_fields,
             mailimf_field_new_custom(
                 strdup(b"X-Mailer\x00" as *const u8 as *const libc::c_char),
-                dc_mprintf(
-                    b"Delta Chat Core %s%s\x00" as *const u8 as *const libc::c_char,
-                    version.as_ptr(),
-                    os_part.as_ptr(),
-                ),
+                format!("Delta Chat Core {}{}", version, os_part).strdup(),
             ),
         );
 
@@ -496,7 +492,8 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
              *********************************************************************/
             let chat = factory.chat.as_ref().unwrap();
             let mut meta_part: *mut mailmime = ptr::null_mut();
-            let mut placeholdertext: *mut libc::c_char = ptr::null_mut();
+            let mut placeholdertext = None;
+
             if chat.typ == Chattype::VerifiedGroup {
                 mailimf_fields_add(
                     imf_fields,
@@ -529,7 +526,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
             }
 
             /* build header etc. */
-            let command = factory.msg.param.get_int(Param::Cmd).unwrap_or_default();
+            let command = factory.msg.param.get_cmd();
             if chat.typ == Chattype::Group || chat.typ == Chattype::VerifiedGroup {
                 mailimf_fields_add(
                     imf_fields,
@@ -538,15 +535,15 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                         chat.grpid.strdup(),
                     ),
                 );
-                let name = CString::yolo(chat.name.as_bytes());
                 mailimf_fields_add(
                     imf_fields,
                     mailimf_field_new_custom(
                         strdup(b"Chat-Group-Name\x00" as *const u8 as *const libc::c_char),
-                        dc_encode_header_words(name.as_ptr()),
+                        dc_encode_header_words(&chat.name),
                     ),
                 );
-                if command == DC_CMD_MEMBER_REMOVED_FROM_GROUP {
+
+                if command == SystemMessage::MemberRemovedFromGroup {
                     let email_to_remove = factory
                         .msg
                         .param
@@ -565,7 +562,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                             ),
                         );
                     }
-                } else if command == DC_CMD_MEMBER_ADDED_TO_GROUP {
+                } else if command == SystemMessage::MemberAddedToGroup {
                     let msg = &factory.msg;
                     do_gossip = 1;
                     let email_to_add = msg.param.get(Param::Arg).unwrap_or_default().strdup();
@@ -596,7 +593,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                             ),
                         );
                     }
-                } else if command == DC_CMD_GROUPNAME_CHANGED {
+                } else if command == SystemMessage::GroupNameChanged {
                     let msg = &factory.msg;
 
                     let value_to_add = msg.param.get(Param::Arg).unwrap_or_default().strdup();
@@ -609,7 +606,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                             value_to_add,
                         ),
                     );
-                } else if command == DC_CMD_GROUPIMAGE_CHANGED {
+                } else if command == SystemMessage::GroupImageChanged {
                     let msg = &factory.msg;
                     grpimage = msg.param.get(Param::Arg);
                     if grpimage.is_none() {
@@ -623,7 +620,8 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                     }
                 }
             }
-            if command == DC_CMD_LOCATION_STREAMING_ENABLED {
+
+            if command == SystemMessage::LocationStreamingEnabled {
                 mailimf_fields_add(
                     imf_fields,
                     mailimf_field_new_custom(
@@ -634,7 +632,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                     ),
                 );
             }
-            if command == DC_CMD_AUTOCRYPT_SETUP_MESSAGE {
+            if command == SystemMessage::AutocryptSetupMessage {
                 mailimf_fields_add(
                     imf_fields,
                     mailimf_field_new_custom(
@@ -642,12 +640,14 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                         strdup(b"v1\x00" as *const u8 as *const libc::c_char),
                     ),
                 );
-                placeholdertext = factory
-                    .context
-                    .stock_str(StockMessage::AcSetupMsgBody)
-                    .strdup();
+                placeholdertext = Some(
+                    factory
+                        .context
+                        .stock_str(StockMessage::AcSetupMsgBody)
+                        .to_string(),
+                );
             }
-            if command == DC_CMD_SECUREJOIN_MESSAGE {
+            if command == SystemMessage::SecurejoinMessage {
                 let msg = &factory.msg;
                 let step = msg.param.get(Param::Arg).unwrap_or_default().strdup();
                 if strlen(step) > 0 {
@@ -721,6 +721,7 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                     }
                 }
             }
+
             if let Some(grpimage) = grpimage {
                 info!(factory.context, "setting group image '{}'", grpimage);
                 let mut meta = dc_msg_new_untyped();
@@ -768,78 +769,68 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
                         imf_fields,
                         mailimf_field_new_custom(
                             strdup(b"Chat-Duration\x00" as *const u8 as *const libc::c_char),
-                            dc_mprintf(
-                                b"%i\x00" as *const u8 as *const libc::c_char,
-                                duration_ms as libc::c_int,
-                            ),
+                            duration_ms.to_string().strdup(),
                         ),
                     );
                 }
             }
             afwd_email = factory.msg.param.exists(Param::Forwarded) as libc::c_int;
-            let mut fwdhint = ptr::null_mut();
-            if 0 != afwd_email {
-                fwdhint = dc_strdup(
-                    b"---------- Forwarded message ----------\r\nFrom: Delta Chat\r\n\r\n\x00"
-                        as *const u8 as *const libc::c_char,
+            let fwdhint = if 0 != afwd_email {
+                Some(
+                    "---------- Forwarded message ----------\r\nFrom: Delta Chat\r\n\r\n"
+                        .to_string(),
                 )
-            }
+            } else {
+                None
+            };
 
             let final_text = {
-                if !placeholdertext.is_null() {
-                    to_string(placeholdertext)
+                if let Some(ref text) = placeholdertext {
+                    text
                 } else if let Some(ref text) = factory.msg.text {
-                    text.clone()
+                    text
                 } else {
-                    "".into()
+                    ""
                 }
             };
-            let final_text = CString::yolo(final_text);
 
-            let footer: *mut libc::c_char = factory.selfstatus;
-            message_text = dc_mprintf(
-                b"%s%s%s%s%s\x00" as *const u8 as *const libc::c_char,
-                if !fwdhint.is_null() {
-                    fwdhint
+            let footer = factory.selfstatus.as_ref();
+
+            message_text = format!(
+                "{}{}{}{}{}",
+                if let Some(ref hint) = fwdhint {
+                    hint
                 } else {
-                    b"\x00" as *const u8 as *const libc::c_char
+                    ""
                 },
-                final_text.as_ptr(),
-                if final_text != CString::yolo("")
-                    && !footer.is_null()
-                    && 0 != *footer.offset(0isize) as libc::c_int
-                {
-                    b"\r\n\r\n\x00" as *const u8 as *const libc::c_char
+                &final_text,
+                if !final_text.is_empty() && footer.is_some() {
+                    "\r\n\r\n"
                 } else {
-                    b"\x00" as *const u8 as *const libc::c_char
+                    ""
                 },
-                if !footer.is_null() && 0 != *footer.offset(0isize) as libc::c_int {
-                    b"-- \r\n\x00" as *const u8 as *const libc::c_char
-                } else {
-                    b"\x00" as *const u8 as *const libc::c_char
-                },
-                if !footer.is_null() && 0 != *footer.offset(0isize) as libc::c_int {
+                if footer.is_some() { "-- \r\n" } else { "" },
+                if let Some(footer) = footer {
                     footer
                 } else {
-                    b"\x00" as *const u8 as *const libc::c_char
+                    ""
                 },
-            );
+            )
+            .strdup();
             let text_part: *mut mailmime = build_body_text(message_text);
             mailmime_smart_add_part(message, text_part);
             parts += 1;
-            free(fwdhint as *mut libc::c_void);
-            free(placeholdertext as *mut libc::c_void);
 
             /* add attachment part */
             if chat::msgtype_has_file(factory.msg.type_0) {
                 if !is_file_size_okay(context, &factory.msg) {
-                    let error: *mut libc::c_char = dc_mprintf(
-                        b"Message exceeds the recommended %i MB.\x00" as *const u8
-                            as *const libc::c_char,
+                    let error = format!(
+                        "Message exceeds the recommended {} MB.",
                         24 * 1024 * 1024 / 4 * 3 / 1000 / 1000,
-                    );
+                    )
+                    .strdup();
                     set_error(factory, error);
-                    free(error as *mut libc::c_void);
+                    free(error.cast());
                     ok_to_continue = false;
                 } else {
                     let file_part: *mut mailmime =
@@ -954,15 +945,14 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
             message_text = format!("{}\r\n", p2).strdup();
             let human_mime_part: *mut mailmime = build_body_text(message_text);
             mailmime_add_part(multipart, human_mime_part);
-            let version = CString::yolo(get_version_str());
-            message_text2 =
-                dc_mprintf(
-                    b"Reporting-UA: Delta Chat %s\r\nOriginal-Recipient: rfc822;%s\r\nFinal-Recipient: rfc822;%s\r\nOriginal-Message-ID: <%s>\r\nDisposition: manual-action/MDN-sent-automatically; displayed\r\n\x00"
-                        as *const u8 as *const libc::c_char,
-                    version.as_ptr(),
-                    factory.from_addr, factory.from_addr,
-                    factory.msg.rfc724_mid
-                );
+            let version = get_version_str();
+            message_text2 = format!(
+                "Reporting-UA: Delta Chat {}\r\nOriginal-Recipient: rfc822;{}\r\nFinal-Recipient: rfc822;{}\r\nOriginal-Message-ID: <{}>\r\nDisposition: manual-action/MDN-sent-automatically; displayed\r\n",
+                version,
+                as_str(factory.from_addr),
+                as_str(factory.from_addr),
+                as_str(factory.msg.rfc724_mid)
+            ).strdup();
 
             let content_type_0: *mut mailmime_content = mailmime_content_new_with_str(
                 b"message/disposition-notification\x00" as *const u8 as *const libc::c_char,
@@ -982,17 +972,19 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
         }
 
         if ok_to_continue {
-            if factory.loaded as libc::c_uint == DC_MF_MDN_LOADED as libc::c_int as libc::c_uint {
-                let e = CString::new(factory.context.stock_str(StockMessage::ReadRcpt).as_ref())
-                    .unwrap();
-                subject_str = dc_mprintf(
-                    b"Chat: %s\x00" as *const u8 as *const libc::c_char,
-                    e.as_ptr(),
-                );
+            let subject_str = if factory.loaded as libc::c_uint == DC_MF_MDN_LOADED as libc::c_uint
+            {
+                let e = factory.context.stock_str(StockMessage::ReadRcpt);
+                format!("Chat: {}", e)
             } else {
-                subject_str =
-                    get_subject(context, factory.chat.as_ref(), &mut factory.msg, afwd_email)
-            }
+                to_string(get_subject(
+                    context,
+                    factory.chat.as_ref(),
+                    &mut factory.msg,
+                    afwd_email,
+                ))
+            };
+
             subject = mailimf_subject_new(dc_encode_header_words(subject_str));
             mailimf_fields_add(
                 imf_fields,
@@ -1051,7 +1043,6 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut dc_mimefact
     e2ee_helper.thanks();
     free(message_text as *mut libc::c_void);
     free(message_text2 as *mut libc::c_void);
-    free(subject_str as *mut libc::c_void);
 
     success
 }
@@ -1069,34 +1060,17 @@ unsafe fn get_subject(
     let chat = chat.unwrap();
     let ret: *mut libc::c_char;
 
-    let raw_subject = {
-        dc_msg_get_summarytext_by_raw(msg.type_0, msg.text.as_ref(), &mut msg.param, 32, context)
-            .strdup()
-    };
+    let raw_subject =
+        dc_msg_get_summarytext_by_raw(msg.type_0, msg.text.as_ref(), &mut msg.param, 32, context);
 
-    let fwd = if 0 != afwd_email {
-        b"Fwd: \x00" as *const u8 as *const libc::c_char
-    } else {
-        b"\x00" as *const u8 as *const libc::c_char
-    };
-    if msg.param.get_int(Param::Cmd).unwrap_or_default() == DC_CMD_AUTOCRYPT_SETUP_MESSAGE {
+    let fwd = if 0 != afwd_email { "Fwd: " } else { "" };
+    if msg.param.get_cmd() == SystemMessage::AutocryptSetupMessage {
         ret = context.stock_str(StockMessage::AcSetupMsgSubject).strdup()
     } else if chat.typ == Chattype::Group || chat.typ == Chattype::VerifiedGroup {
-        ret = format!(
-            "Chat: {}: {}{}",
-            chat.name,
-            to_string(fwd),
-            to_string(raw_subject),
-        )
-        .strdup()
+        ret = format!("Chat: {}: {}{}", chat.name, fwd, raw_subject,).strdup();
     } else {
-        ret = dc_mprintf(
-            b"Chat: %s%s\x00" as *const u8 as *const libc::c_char,
-            fwd,
-            raw_subject,
-        )
+        ret = format!("Chat: {}{}", fwd, raw_subject).strdup();
     }
-    free(raw_subject as *mut libc::c_void);
 
     ret
 }
@@ -1148,13 +1122,12 @@ unsafe fn build_body_file(
         .map(|s| s.strdup())
         .unwrap_or_else(|| std::ptr::null_mut());
 
-    let mut filename_to_send = ptr::null_mut();
     let mut filename_encoded = ptr::null_mut();
 
     if let Some(ref path_filename) = path_filename {
         let suffix = dc_get_filesuffix_lc(path_filename);
 
-        if msg.type_0 == Viewtype::Voice {
+        let filename_to_send = if msg.type_0 == Viewtype::Voice {
             let ts = chrono::Utc.timestamp(msg.timestamp_sort as i64, 0);
 
             let suffix = if !suffix.is_null() {
@@ -1162,37 +1135,42 @@ unsafe fn build_body_file(
             } else {
                 "dat".into()
             };
-            let res = ts
-                .format(&format!("voice-message_%Y-%m-%d_%H-%M-%S.{}", suffix))
-                .to_string();
-            filename_to_send = res.strdup();
+            ts.format(&format!("voice-message_%Y-%m-%d_%H-%M-%S.{}", suffix))
+                .to_string()
         } else if msg.type_0 == Viewtype::Audio {
-            filename_to_send = dc_get_filename(path_filename)
+            Path::new(path_filename)
+                .file_name()
+                .map(|c| c.to_string_lossy().to_string())
+                .unwrap_or_default()
         } else if msg.type_0 == Viewtype::Image || msg.type_0 == Viewtype::Gif {
             if base_name.is_null() {
                 base_name = b"image\x00" as *const u8 as *const libc::c_char
             }
-            filename_to_send = dc_mprintf(
-                b"%s.%s\x00" as *const u8 as *const libc::c_char,
-                base_name,
+            format!(
+                "{}.{}",
+                as_str(base_name),
                 if !suffix.is_null() {
-                    suffix
+                    as_str(suffix)
                 } else {
-                    b"dat\x00" as *const u8 as *const libc::c_char
+                    "dat"
                 },
             )
         } else if msg.type_0 == Viewtype::Video {
-            filename_to_send = dc_mprintf(
-                b"video.%s\x00" as *const u8 as *const libc::c_char,
+            format!(
+                "video.{}",
                 if !suffix.is_null() {
-                    suffix
+                    as_str(suffix)
                 } else {
-                    b"dat\x00" as *const u8 as *const libc::c_char
+                    "dat"
                 },
             )
         } else {
-            filename_to_send = dc_get_filename(path_filename)
-        }
+            Path::new(path_filename)
+                .file_name()
+                .map(|c| c.to_string_lossy().to_string())
+                .unwrap_or_default()
+        };
+
         if mimetype.is_null() {
             if suffix.is_null() {
                 mimetype =
@@ -1215,13 +1193,13 @@ unsafe fn build_body_file(
             /* create mime part, for Content-Disposition, see RFC 2183.
             `Content-Disposition: attachment` seems not to make a difference to `Content-Disposition: inline` at least on tested Thunderbird and Gma'l in 2017.
             But I've heard about problems with inline and outl'k, so we just use the attachment-type until we run into other problems ... */
-            needs_ext = dc_needs_ext_header(as_str(filename_to_send));
+            needs_ext = dc_needs_ext_header(&filename_to_send);
             mime_fields = mailmime_fields_new_filename(
                 MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
                 if needs_ext {
                     ptr::null_mut()
                 } else {
-                    dc_strdup(filename_to_send)
+                    filename_to_send.strdup()
                 },
                 MAILMIME_MECHANISM_BASE64 as libc::c_int,
             );
@@ -1252,7 +1230,7 @@ unsafe fn build_body_file(
                                         strdup(
                                             b"filename*\x00" as *const u8 as *const libc::c_char,
                                         ),
-                                        dc_encode_ext_header(as_str(filename_to_send)).strdup(),
+                                        dc_encode_ext_header(&filename_to_send).strdup(),
                                     ),
                                 );
                             if !parm.is_null() {
@@ -1274,7 +1252,7 @@ unsafe fn build_body_file(
                 }
             }
             content = mailmime_content_new_with_str(mimetype);
-            filename_encoded = dc_encode_header_words(filename_to_send);
+            filename_encoded = dc_encode_header_words(&filename_to_send);
             clist_insert_after(
                 (*content).ct_parameters,
                 (*(*content).ct_parameters).last,
@@ -1289,13 +1267,12 @@ unsafe fn build_body_file(
                 .unwrap();
             mailmime_set_body_file(mime_sub, dc_strdup(abs_path.as_ptr()));
             if !ret_file_name_as_sent.is_null() {
-                *ret_file_name_as_sent = dc_strdup(filename_to_send)
+                *ret_file_name_as_sent = filename_to_send.strdup();
             }
         }
     }
 
     free(mimetype as *mut libc::c_void);
-    free(filename_to_send as *mut libc::c_void);
     free(filename_encoded as *mut libc::c_void);
 
     mime_sub

src/dc_receive_imf.rs

@@ -63,7 +63,8 @@ pub unsafe fn dc_receive_imf(
     // somewhen, I did not found out anything that speaks against this approach yet)
 
     let body = std::slice::from_raw_parts(imf_raw_not_terminated as *const u8, imf_raw_bytes);
-    let mut mime_parser = dc_mimeparser_parse(context, body);
+    let mut mime_parser = MimeParser::new(context);
+    mime_parser.parse(body);
 
     if mime_parser.header.is_empty() {
         // Error - even adding an empty record won't help as we do not know the message ID
@@ -124,7 +125,7 @@ pub unsafe fn dc_receive_imf(
         }
     };
 
-    if let Some(field) = lookup_field(&mime_parser, "Date", MAILIMF_FIELD_ORIG_DATE) {
+    if let Some(field) = mime_parser.lookup_field_typ("Date", MAILIMF_FIELD_ORIG_DATE) {
         let orig_date = (*field).fld_data.fld_orig_date;
         if !orig_date.is_null() {
             // is not yet checked against bad times! we do this later if we have the database information.
@@ -135,7 +136,7 @@ pub unsafe fn dc_receive_imf(
     // get From: and check if it is known (for known From:'s we add the other To:/Cc: in the 3rd pass)
     // or if From: is equal to SELF (in this case, it is any outgoing messages,
     // we do not check Return-Path any more as this is unreliable, see issue #150
-    if let Some(field) = lookup_field(&mime_parser, "From", MAILIMF_FIELD_FROM) {
+    if let Some(field) = mime_parser.lookup_field_typ("From", MAILIMF_FIELD_FROM) {
         let fld_from = (*field).fld_data.fld_from;
         if !fld_from.is_null() {
             let mut check_self = 0;
@@ -149,7 +150,7 @@ pub unsafe fn dc_receive_imf(
             );
             if 0 != check_self {
                 incoming = 0;
-                if 0 != dc_mimeparser_sender_equals_recipient(&mime_parser) {
+                if mime_parser.sender_equals_recipient() {
                     from_id = DC_CONTACT_ID_SELF;
                 }
             } else if from_list.len() >= 1 {
@@ -163,7 +164,7 @@ pub unsafe fn dc_receive_imf(
     }
 
     // Make sure, to_ids starts with the first To:-address (Cc: is added in the loop below pass)
-    if let Some(field) = lookup_field(&mime_parser, "To", MAILIMF_FIELD_TO) {
+    if let Some(field) = mime_parser.lookup_field_typ("To", MAILIMF_FIELD_TO) {
         let fld_to = (*field).fld_data.fld_to;
         if !fld_to.is_null() {
             dc_add_or_lookup_contacts_by_address_list(
@@ -183,7 +184,7 @@ pub unsafe fn dc_receive_imf(
     }
 
     // Add parts
-    if dc_mimeparser_get_last_nonmeta(&mut mime_parser).is_some() {
+    if mime_parser.get_last_nonmeta().is_some() {
         if let Err(err) = add_parts(
             context,
             &mut mime_parser,
@@ -278,7 +279,7 @@ pub unsafe fn dc_receive_imf(
 
 unsafe fn add_parts(
     context: &Context,
-    mut mime_parser: &mut dc_mimeparser_t,
+    mut mime_parser: &mut MimeParser,
     imf_raw_not_terminated: *const libc::c_char,
     imf_raw_bytes: libc::size_t,
     incoming: i32,
@@ -307,20 +308,16 @@ unsafe fn add_parts(
     let mut rcvd_timestamp = 0;
     let mut mime_in_reply_to = std::ptr::null_mut();
     let mut mime_references = std::ptr::null_mut();
-    let mut txt_raw = std::ptr::null_mut();
 
-    let cleanup = |mime_in_reply_to: *mut libc::c_char,
-                   mime_references: *mut libc::c_char,
-                   txt_raw: *mut libc::c_char| {
+    let cleanup = |mime_in_reply_to: *mut libc::c_char, mime_references: *mut libc::c_char| {
         free(mime_in_reply_to.cast());
         free(mime_references.cast());
-        free(txt_raw.cast());
     };
 
     // collect the rest information, CC: is added to the to-list, BCC: is ignored
     // (we should not add BCC to groups as this would split groups. We could add them as "known contacts",
     // however, the benefit is very small and this may leak data that is expected to be hidden)
-    if let Some(field) = lookup_field(mime_parser, "Cc", MAILIMF_FIELD_CC) {
+    if let Some(field) = mime_parser.lookup_field_typ("Cc", MAILIMF_FIELD_CC) {
         let fld_cc = (*field).fld_data.fld_cc;
         if !fld_cc.is_null() {
             dc_add_or_lookup_contacts_by_address_list(
@@ -343,7 +340,7 @@ unsafe fn add_parts(
     // change. (missing Message-IDs may come if the mail was set from this account with another
     // client that relies in the SMTP server to generate one.
     // true eg. for the Webmailer used in all-inkl-KAS)
-    if let Some(field) = lookup_field(mime_parser, "Message-ID", MAILIMF_FIELD_MESSAGE_ID) {
+    if let Some(field) = mime_parser.lookup_field_typ("Message-ID", MAILIMF_FIELD_MESSAGE_ID) {
         let fld_message_id = (*field).fld_data.fld_message_id;
         if !fld_message_id.is_null() {
             rfc724_mid = dc_strdup((*fld_message_id).mid_value)
@@ -353,7 +350,7 @@ unsafe fn add_parts(
     if rfc724_mid.is_null() {
         rfc724_mid = dc_create_incoming_rfc724_mid(*sent_timestamp, *from_id, to_ids);
         if rfc724_mid.is_null() {
-            cleanup(mime_in_reply_to, mime_references, txt_raw);
+            cleanup(mime_in_reply_to, mime_references);
             bail!("Cannot create Message-ID");
         }
     }
@@ -375,7 +372,7 @@ unsafe fn add_parts(
         }
 
         free(old_server_folder.cast());
-        cleanup(mime_in_reply_to, mime_references, txt_raw);
+        cleanup(mime_in_reply_to, mime_references);
         bail!("Message already in DB");
     }
 
@@ -388,7 +385,7 @@ unsafe fn add_parts(
     // incoming non-chat messages may be discarded;
     // maybe this can be optimized later, by checking the state before the message body is downloaded
     let mut allow_creation = 1;
-    if mime_parser.is_system_message != DC_CMD_AUTOCRYPT_SETUP_MESSAGE && msgrmsg == 0 {
+    if mime_parser.is_system_message != SystemMessage::AutocryptSetupMessage && msgrmsg == 0 {
         let show_emails = context
             .sql
             .get_config_int(context, "show_emails")
@@ -414,7 +411,7 @@ unsafe fn add_parts(
         *to_id = 1;
         // handshake messages must be processed _before_ chats are created
         // (eg. contacs may be marked as verified)
-        if !dc_mimeparser_lookup_field(mime_parser, "Secure-Join").is_null() {
+        if mime_parser.lookup_field("Secure-Join").is_some() {
             // avoid discarding by show_emails setting
             msgrmsg = 1;
             *chat_id = 0;
@@ -463,7 +460,7 @@ unsafe fn add_parts(
 
         if *chat_id == 0 {
             // check if the message belongs to a mailing list
-            if dc_mimeparser_is_mailinglist_message(mime_parser) {
+            if mime_parser.is_mailinglist_message() {
                 *chat_id = 3;
                 info!(context, "Message belongs to a mailing list and is ignored.",);
             }
@@ -601,11 +598,8 @@ unsafe fn add_parts(
 
     // if the mime-headers should be saved, find out its size
     // (the mime-header ends with an empty line)
-    let save_mime_headers = context
-        .sql
-        .get_config_int(context, "save_mime_headers")
-        .unwrap_or_default();
-    if let Some(field) = lookup_field(mime_parser, "In-Reply-To", MAILIMF_FIELD_IN_REPLY_TO) {
+    let save_mime_headers = context.sql.get_config_bool(context, "save_mime_headers");
+    if let Some(field) = mime_parser.lookup_field_typ("In-Reply-To", MAILIMF_FIELD_IN_REPLY_TO) {
         let fld_in_reply_to = (*field).fld_data.fld_in_reply_to;
         if !fld_in_reply_to.is_null() {
             mime_in_reply_to = dc_str_from_clist(
@@ -615,7 +609,7 @@ unsafe fn add_parts(
         }
     }
 
-    if let Some(field) = lookup_field(mime_parser, "References", MAILIMF_FIELD_REFERENCES) {
+    if let Some(field) = mime_parser.lookup_field_typ("References", MAILIMF_FIELD_REFERENCES) {
         let fld_references = (*field).fld_data.fld_references;
         if !fld_references.is_null() {
             mime_references = dc_str_from_clist(
@@ -630,6 +624,8 @@ unsafe fn add_parts(
     // into only one message; mails sent by other clients may result in several messages
     // (eg. one per attachment))
     let icnt = mime_parser.parts.len();
+    let mut txt_raw = None;
+
     let is_ok = context
         .sql
         .prepare(
@@ -656,25 +652,18 @@ unsafe fn add_parts(
                             }
                         }
                     }
-                    if part.type_0 == Viewtype::Text {
-                        let msg_raw =
-                            CString::yolo(part.msg_raw.as_ref().cloned().unwrap_or_default());
-                        let subject_c = CString::yolo(
-                            mime_parser
-                                .subject
-                                .as_ref()
-                                .map(|s| s.to_string())
-                                .unwrap_or("".into()),
-                        );
-                        txt_raw = dc_mprintf(
-                            b"%s\n\n%s\x00" as *const u8 as *const libc::c_char,
-                            subject_c.as_ptr(),
-                            msg_raw.as_ptr(),
-                        )
+                    if part.typ == Viewtype::Text {
+                        let msg_raw = part.msg_raw.as_ref().cloned().unwrap_or_default();
+                        let subject = mime_parser
+                            .subject
+                            .as_ref()
+                            .map(|s| s.to_string())
+                            .unwrap_or("".into());
+                        txt_raw = Some(format!("{}\n\n{}", subject, msg_raw));
                     }
-                    if 0 != mime_parser.is_system_message {
+                    if mime_parser.is_system_message != SystemMessage::Unknown {
                         part.param
-                            .set_int(Param::Cmd, mime_parser.is_system_message);
+                            .set_int(Param::Cmd, mime_parser.is_system_message as i32);
                     }
 
                     stmt.execute(params![
@@ -687,27 +676,20 @@ unsafe fn add_parts(
                         sort_timestamp,
                         *sent_timestamp,
                         rcvd_timestamp,
-                        part.type_0,
+                        part.typ,
                         state,
                         msgrmsg,
                         part.msg.as_ref().map_or("", String::as_str),
                         // txt_raw might contain invalid utf8
-                        if !txt_raw.is_null() {
-                            to_string_lossy(txt_raw)
-                        } else {
-                            String::new()
-                        },
+                        txt_raw.unwrap_or_default(),
                         part.param.to_string(),
                         part.bytes,
                         *hidden,
-                        if 0 != save_mime_headers {
-                            let body_string = std::str::from_utf8(std::slice::from_raw_parts(
+                        if save_mime_headers {
+                            Some(String::from_utf8_lossy(std::slice::from_raw_parts(
                                 imf_raw_not_terminated as *const u8,
                                 imf_raw_bytes,
-                            ))
-                            .unwrap();
-
-                            Some(body_string)
+                            )))
                         } else {
                             None
                         },
@@ -715,8 +697,7 @@ unsafe fn add_parts(
                         to_string(mime_references),
                     ])?;
 
-                    free(txt_raw as *mut libc::c_void);
-                    txt_raw = ptr::null_mut();
+                    txt_raw = None;
                     *insert_msg_id = sql::get_rowid_with_conn(
                         context,
                         conn,
@@ -733,7 +714,7 @@ unsafe fn add_parts(
 
     if !is_ok {
         // i/o error - there is nothing more we can do - in other cases, we try to write at least an empty record
-        cleanup(mime_in_reply_to, mime_references, txt_raw);
+        cleanup(mime_in_reply_to, mime_references);
         bail!("Cannot write DB.");
     }
 
@@ -756,29 +737,15 @@ unsafe fn add_parts(
     }
 
     context.do_heuristics_moves(server_folder.as_ref(), *insert_msg_id);
-    cleanup(mime_in_reply_to, mime_references, txt_raw);
+    cleanup(mime_in_reply_to, mime_references);
 
     Ok(())
 }
 
-/// Lookup a mime field given its name and type.
-unsafe fn lookup_field(
-    parser: &dc_mimeparser_t,
-    name: &str,
-    typ: u32,
-) -> Option<*const mailimf_field> {
-    let field = dc_mimeparser_lookup_field(parser, name);
-    if !field.is_null() && (*field).fld_type == typ as libc::c_int {
-        Some(field)
-    } else {
-        None
-    }
-}
-
 // Handle reports (mainly MDNs)
 unsafe fn handle_reports(
     context: &Context,
-    mime_parser: &dc_mimeparser_t,
+    mime_parser: &MimeParser,
     from_id: u32,
     sent_timestamp: i64,
     rr_event_to_send: &mut Vec<(u32, u32)>,
@@ -941,7 +908,7 @@ unsafe fn handle_reports(
 
 fn save_locations(
     context: &Context,
-    mime_parser: &dc_mimeparser_t,
+    mime_parser: &MimeParser,
     chat_id: u32,
     from_id: u32,
     insert_msg_id: u32,
@@ -1039,7 +1006,7 @@ unsafe fn calc_timestamps(
 #[allow(non_snake_case)]
 unsafe fn create_or_lookup_group(
     context: &Context,
-    mime_parser: &mut dc_mimeparser_t,
+    mime_parser: &mut MimeParser,
     allow_creation: libc::c_int,
     create_blocked: Blocked,
     from_id: u32,
@@ -1051,28 +1018,20 @@ unsafe fn create_or_lookup_group(
     let mut chat_id = 0;
     let mut chat_id_blocked = Blocked::Not;
     let mut grpid = "".to_string();
-    let mut grpname = std::ptr::null_mut();
+    let mut grpname = None;
     let to_ids_cnt = to_ids.len();
     let mut recreate_member_list = 0;
     let mut send_EVENT_CHAT_MODIFIED = 0;
-    // pointer somewhere into mime_parser, must not be freed
-    let mut X_MrRemoveFromGrp = std::ptr::null_mut();
-    // pointer somewhere into mime_parser, must not be freed
-    let mut X_MrAddToGrp = std::ptr::null_mut();
+    let mut X_MrRemoveFromGrp = None;
+    let mut X_MrAddToGrp = None;
     let mut X_MrGrpNameChanged = 0;
     let mut X_MrGrpImageChanged = "".to_string();
     let mut better_msg: String = From::from("");
-    let mut failure_reason = std::ptr::null_mut();
 
-    let cleanup = |grpname: *mut libc::c_char,
-                   failure_reason: *mut libc::c_char,
-                   ret_chat_id: *mut u32,
+    let cleanup = |ret_chat_id: *mut u32,
                    ret_chat_id_blocked: &mut Blocked,
                    chat_id: u32,
                    chat_id_blocked: Blocked| {
-        free(grpname.cast());
-        free(failure_reason.cast());
-
         if !ret_chat_id.is_null() {
             *ret_chat_id = chat_id;
         }
@@ -1083,18 +1042,18 @@ unsafe fn create_or_lookup_group(
         };
     };
 
-    if mime_parser.is_system_message == DC_CMD_LOCATION_STREAMING_ENABLED {
+    if mime_parser.is_system_message == SystemMessage::LocationStreamingEnabled {
         better_msg =
             context.stock_system_msg(StockMessage::MsgLocationEnabled, "", "", from_id as u32)
     }
     set_better_msg(mime_parser, &better_msg);
 
-    let optional_field = dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-ID");
-    if !optional_field.is_null() {
-        grpid = to_string((*optional_field).fld_value)
+    if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-ID") {
+        grpid = optional_field;
     }
+
     if grpid.is_empty() {
-        if let Some(field) = lookup_field(mime_parser, "Message-ID", MAILIMF_FIELD_MESSAGE_ID) {
+        if let Some(field) = mime_parser.lookup_field_typ("Message-ID", MAILIMF_FIELD_MESSAGE_ID) {
             let fld_message_id = (*field).fld_data.fld_message_id;
             if !fld_message_id.is_null() {
                 if let Some(extracted_grpid) =
@@ -1107,7 +1066,8 @@ unsafe fn create_or_lookup_group(
             }
         }
         if grpid.is_empty() {
-            if let Some(field) = lookup_field(mime_parser, "In-Reply-To", MAILIMF_FIELD_IN_REPLY_TO)
+            if let Some(field) =
+                mime_parser.lookup_field_typ("In-Reply-To", MAILIMF_FIELD_IN_REPLY_TO)
             {
                 let fld_in_reply_to = (*field).fld_data.fld_in_reply_to;
                 if !fld_in_reply_to.is_null() {
@@ -1118,7 +1078,7 @@ unsafe fn create_or_lookup_group(
             }
             if grpid.is_empty() {
                 if let Some(field) =
-                    lookup_field(mime_parser, "References", MAILIMF_FIELD_REFERENCES)
+                    mime_parser.lookup_field_typ("References", MAILIMF_FIELD_REFERENCES)
                 {
                     let fld_references = (*field).fld_data.fld_references;
                     if !fld_references.is_null() {
@@ -1139,30 +1099,20 @@ unsafe fn create_or_lookup_group(
                         &mut chat_id,
                         &mut chat_id_blocked,
                     );
-                    cleanup(
-                        grpname,
-                        failure_reason,
-                        ret_chat_id,
-                        ret_chat_id_blocked,
-                        chat_id,
-                        chat_id_blocked,
-                    );
+                    cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
                     return;
                 }
             }
         }
     }
 
-    let optional_field = dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-Name");
-    if !optional_field.is_null() {
-        grpname = dc_decode_header_words((*optional_field).fld_value)
+    if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Name") {
+        grpname = Some(dc_decode_header_words_safe(&optional_field));
     }
-    let optional_field =
-        dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-Member-Removed");
-    if !optional_field.is_null() {
-        X_MrRemoveFromGrp = (*optional_field).fld_value;
-        mime_parser.is_system_message = DC_CMD_MEMBER_REMOVED_FROM_GROUP;
-        let left_group = (Contact::lookup_id_by_addr(context, as_str(X_MrRemoveFromGrp))
+    if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Member-Removed") {
+        X_MrRemoveFromGrp = Some(optional_field);
+        mime_parser.is_system_message = SystemMessage::MemberRemovedFromGroup;
+        let left_group = (Contact::lookup_id_by_addr(context, X_MrRemoveFromGrp.as_ref().unwrap())
             == from_id as u32) as libc::c_int;
         better_msg = context.stock_system_msg(
             if 0 != left_group {
@@ -1170,47 +1120,45 @@ unsafe fn create_or_lookup_group(
             } else {
                 StockMessage::MsgDelMember
             },
-            as_str(X_MrRemoveFromGrp),
+            X_MrRemoveFromGrp.as_ref().unwrap(),
             "",
             from_id as u32,
         )
     } else {
-        let optional_field =
-            dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-Member-Added");
-        if !optional_field.is_null() {
-            X_MrAddToGrp = (*optional_field).fld_value;
-            mime_parser.is_system_message = DC_CMD_MEMBER_ADDED_TO_GROUP;
-            let optional_field =
-                dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-Image");
-            if !optional_field.is_null() {
-                // fld_value is a pointer somewhere into mime_parser, must not be freed
-                X_MrGrpImageChanged = as_str((*optional_field).fld_value).to_string();
+        if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Member-Added") {
+            X_MrAddToGrp = Some(optional_field);
+            mime_parser.is_system_message = SystemMessage::MemberAddedToGroup;
+            if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Image") {
+                X_MrGrpImageChanged = optional_field;
             }
             better_msg = context.stock_system_msg(
                 StockMessage::MsgAddMember,
-                as_str(X_MrAddToGrp),
+                X_MrAddToGrp.as_ref().unwrap(),
                 "",
                 from_id as u32,
             )
         } else {
-            let optional_field =
-                dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-Name-Changed");
-            if !optional_field.is_null() {
+            if let Some(optional_field) =
+                mime_parser.lookup_optional_field("Chat-Group-Name-Changed")
+            {
                 X_MrGrpNameChanged = 1;
-                mime_parser.is_system_message = DC_CMD_GROUPNAME_CHANGED;
+                mime_parser.is_system_message = SystemMessage::GroupNameChanged;
                 better_msg = context.stock_system_msg(
                     StockMessage::MsgGrpName,
-                    as_str((*optional_field).fld_value),
-                    as_str(grpname),
+                    &optional_field,
+                    if let Some(ref name) = grpname {
+                        name
+                    } else {
+                        ""
+                    },
                     from_id as u32,
                 )
             } else {
-                let optional_field =
-                    dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Group-Image");
-                if !optional_field.is_null() {
+                if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Image")
+                {
                     // fld_value is a pointer somewhere into mime_parser, must not be freed
-                    X_MrGrpImageChanged = as_str((*optional_field).fld_value).to_string();
-                    mime_parser.is_system_message = DC_CMD_GROUPIMAGE_CHANGED;
+                    X_MrGrpImageChanged = optional_field;
+                    mime_parser.is_system_message = SystemMessage::GroupImageChanged;
                     better_msg = context.stock_system_msg(
                         if X_MrGrpImageChanged == "0" {
                             StockMessage::MsgGrpImgDeleted
@@ -1230,6 +1178,8 @@ unsafe fn create_or_lookup_group(
     // check, if we have a chat with this group ID
     let (mut chat_id, chat_id_verified, _blocked) = chat::get_chat_id_by_grpid(context, &grpid);
     if chat_id != 0 {
+        let mut failure_reason = std::ptr::null_mut();
+
         if chat_id_verified
             && 0 == check_verified_properties(
                 context,
@@ -1239,8 +1189,10 @@ unsafe fn create_or_lookup_group(
                 &mut failure_reason,
             )
         {
-            dc_mimeparser_repl_msg_by_error(mime_parser, failure_reason);
+            mime_parser.repl_msg_by_error(to_string(failure_reason));
         }
+
+        free(failure_reason.cast());
     }
 
     // check if the sender is a member of the existing group -
@@ -1257,18 +1209,20 @@ unsafe fn create_or_lookup_group(
         .get_config(context, "configured_addr")
         .unwrap_or_default();
     if chat_id == 0
-            && !dc_mimeparser_is_mailinglist_message(mime_parser)
+            && !mime_parser.is_mailinglist_message()
             && !grpid.is_empty()
-            && !grpname.is_null()
+            && grpname.is_some()
             // otherwise, a pending "quit" message may pop up
-            && X_MrRemoveFromGrp.is_null()
+            && X_MrRemoveFromGrp.is_none()
             // re-create explicitly left groups only if ourself is re-added
             && (!group_explicitly_left
-                || !X_MrAddToGrp.is_null() && addr_cmp(&self_addr, as_str(X_MrAddToGrp)))
+                || X_MrAddToGrp.is_some() && addr_cmp(&self_addr, X_MrAddToGrp.as_ref().unwrap()))
     {
         let mut create_verified = VerifiedStatus::Unverified;
-        if !dc_mimeparser_lookup_field(mime_parser, "Chat-Verified").is_null() {
+        if mime_parser.lookup_field("Chat-Verified").is_some() {
             create_verified = VerifiedStatus::Verified;
+            let mut failure_reason = std::ptr::null_mut();
+
             if 0 == check_verified_properties(
                 context,
                 mime_parser,
@@ -1276,21 +1230,21 @@ unsafe fn create_or_lookup_group(
                 to_ids,
                 &mut failure_reason,
             ) {
-                dc_mimeparser_repl_msg_by_error(mime_parser, failure_reason);
+                mime_parser.repl_msg_by_error(to_string(failure_reason));
             }
+            free(failure_reason.cast());
         }
         if 0 == allow_creation {
-            cleanup(
-                grpname,
-                failure_reason,
-                ret_chat_id,
-                ret_chat_id_blocked,
-                chat_id,
-                chat_id_blocked,
-            );
+            cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
             return;
         }
-        chat_id = create_group_record(context, &grpid, grpname, create_blocked, create_verified);
+        chat_id = create_group_record(
+            context,
+            &grpid,
+            grpname.as_ref().unwrap(),
+            create_blocked,
+            create_verified,
+        );
         chat_id_blocked = create_blocked;
         recreate_member_list = 1;
     }
@@ -1312,31 +1266,28 @@ unsafe fn create_or_lookup_group(
                 &mut chat_id_blocked,
             );
         }
-        cleanup(
-            grpname,
-            failure_reason,
-            ret_chat_id,
-            ret_chat_id_blocked,
-            chat_id,
-            chat_id_blocked,
-        );
+        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
         return;
     }
 
     // execute group commands
-    if !X_MrAddToGrp.is_null() || !X_MrRemoveFromGrp.is_null() {
+    if X_MrAddToGrp.is_some() || X_MrRemoveFromGrp.is_some() {
         recreate_member_list = 1;
-    } else if 0 != X_MrGrpNameChanged && !grpname.is_null() && strlen(grpname) < 200 {
-        info!(context, "updating grpname for chat {}", chat_id);
-        if sql::execute(
-            context,
-            &context.sql,
-            "UPDATE chats SET name=? WHERE id=?;",
-            params![as_str(grpname), chat_id as i32],
-        )
-        .is_ok()
-        {
-            context.call_cb(Event::ChatModified(chat_id));
+    } else if 0 != X_MrGrpNameChanged {
+        if let Some(ref grpname) = grpname {
+            if grpname.len() < 200 {
+                info!(context, "updating grpname for chat {}", chat_id);
+                if sql::execute(
+                    context,
+                    &context.sql,
+                    "UPDATE chats SET name=? WHERE id=?;",
+                    params![grpname, chat_id as i32],
+                )
+                .is_ok()
+                {
+                    context.call_cb(Event::ChatModified(chat_id));
+                }
+            }
         }
     }
     if !X_MrGrpImageChanged.is_empty() {
@@ -1350,7 +1301,7 @@ unsafe fn create_or_lookup_group(
             changed = true;
         } else {
             for part in &mut mime_parser.parts {
-                if part.type_0 == Viewtype::Image {
+                if part.typ == Viewtype::Image {
                     grpimage = part
                         .param
                         .get(Param::File)
@@ -1382,11 +1333,7 @@ unsafe fn create_or_lookup_group(
         // than the one that is responsible for the current member list, see
         // https://github.com/deltachat/deltachat-core/issues/127
 
-        let skip = if !X_MrRemoveFromGrp.is_null() {
-            X_MrRemoveFromGrp
-        } else {
-            ptr::null_mut()
-        };
+        let skip = X_MrRemoveFromGrp.as_ref();
         sql::execute(
             context,
             &context.sql,
@@ -1394,21 +1341,20 @@ unsafe fn create_or_lookup_group(
             params![chat_id as i32],
         )
         .ok();
-        if skip.is_null() || !addr_cmp(&self_addr, as_str(skip)) {
+        if skip.is_none() || !addr_cmp(&self_addr, skip.unwrap()) {
             chat::add_to_chat_contacts_table(context, chat_id, DC_CONTACT_ID_SELF);
         }
         if from_id > DC_CHAT_ID_LAST_SPECIAL {
             if !Contact::addr_equals_contact(context, &self_addr, from_id as u32)
-                && (skip.is_null()
-                    || !Contact::addr_equals_contact(context, to_string(skip), from_id as u32))
+                && (skip.is_none()
+                    || !Contact::addr_equals_contact(context, skip.unwrap(), from_id as u32))
             {
                 chat::add_to_chat_contacts_table(context, chat_id, from_id as u32);
             }
         }
         for &to_id in to_ids.iter() {
             if !Contact::addr_equals_contact(context, &self_addr, to_id)
-                && (skip.is_null()
-                    || !Contact::addr_equals_contact(context, to_string(skip), to_id))
+                && (skip.is_none() || !Contact::addr_equals_contact(context, skip.unwrap(), to_id))
             {
                 chat::add_to_chat_contacts_table(context, chat_id, to_id);
             }
@@ -1442,20 +1388,13 @@ unsafe fn create_or_lookup_group(
         }
     }
 
-    cleanup(
-        grpname,
-        failure_reason,
-        ret_chat_id,
-        ret_chat_id_blocked,
-        chat_id,
-        chat_id_blocked,
-    );
+    cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
 }
 
 /// Handle groups for received messages
 unsafe fn create_or_lookup_adhoc_group(
     context: &Context,
-    mime_parser: &dc_mimeparser_t,
+    mime_parser: &MimeParser,
     allow_creation: libc::c_int,
     create_blocked: Blocked,
     from_id: u32,
@@ -1467,15 +1406,11 @@ unsafe fn create_or_lookup_adhoc_group(
     // group matching the to-list or if we can create one
     let mut chat_id = 0;
     let mut chat_id_blocked = Blocked::Not;
-    let mut grpname = ptr::null_mut();
 
-    let cleanup = |grpname: *mut libc::c_char,
-                   ret_chat_id: *mut u32,
+    let cleanup = |ret_chat_id: *mut u32,
                    ret_chat_id_blocked: &mut Blocked,
                    chat_id: u32,
                    chat_id_blocked: Blocked| {
-        free(grpname as *mut libc::c_void);
-
         if !ret_chat_id.is_null() {
             *ret_chat_id = chat_id;
         }
@@ -1483,15 +1418,9 @@ unsafe fn create_or_lookup_adhoc_group(
     };
 
     // build member list from the given ids
-    if to_ids.is_empty() || dc_mimeparser_is_mailinglist_message(mime_parser) {
+    if to_ids.is_empty() || mime_parser.is_mailinglist_message() {
         // too few contacts or a mailinglist
-        cleanup(
-            grpname,
-            ret_chat_id,
-            ret_chat_id_blocked,
-            chat_id,
-            chat_id_blocked,
-        );
+        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
         return;
     }
 
@@ -1504,13 +1433,7 @@ unsafe fn create_or_lookup_adhoc_group(
     }
     if member_ids.len() < 3 {
         // too few contacts given
-        cleanup(
-            grpname,
-            ret_chat_id,
-            ret_chat_id_blocked,
-            chat_id,
-            chat_id_blocked,
-        );
+        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
         return;
     }
 
@@ -1533,25 +1456,13 @@ unsafe fn create_or_lookup_adhoc_group(
             chat_id = id as u32;
             chat_id_blocked = id_blocked;
             /* success, chat found */
-            cleanup(
-                grpname,
-                ret_chat_id,
-                ret_chat_id_blocked,
-                chat_id,
-                chat_id_blocked,
-            );
+            cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
             return;
         }
     }
 
     if 0 == allow_creation {
-        cleanup(
-            grpname,
-            ret_chat_id,
-            ret_chat_id_blocked,
-            chat_id,
-            chat_id_blocked,
-        );
+        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
         return;
     }
     // we do not check if the message is a reply to another group, this may result in
@@ -1561,24 +1472,16 @@ unsafe fn create_or_lookup_adhoc_group(
     // - there is no need to check if this group exists; otherwise we would have caught it above
     let grpid = create_adhoc_grp_id(context, &member_ids);
     if grpid.is_empty() {
-        cleanup(
-            grpname,
-            ret_chat_id,
-            ret_chat_id_blocked,
-            chat_id,
-            chat_id_blocked,
-        );
+        cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
         return;
     }
 
     // use subject as initial chat name
-    if let Some(subject) = mime_parser.subject.as_ref().filter(|s| !s.is_empty()) {
-        grpname = subject.strdup();
+    let grpname = if let Some(subject) = mime_parser.subject.as_ref().filter(|s| !s.is_empty()) {
+        subject.to_string()
     } else {
-        grpname = context
-            .stock_string_repl_int(StockMessage::Member, member_ids.len() as libc::c_int)
-            .strdup();
-    }
+        context.stock_string_repl_int(StockMessage::Member, member_ids.len() as libc::c_int)
+    };
 
     // create group record
     chat_id = create_group_record(
@@ -1595,19 +1498,13 @@ unsafe fn create_or_lookup_adhoc_group(
 
     context.call_cb(Event::ChatModified(chat_id));
 
-    cleanup(
-        grpname,
-        ret_chat_id,
-        ret_chat_id_blocked,
-        chat_id,
-        chat_id_blocked,
-    );
+    cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
 }
 
 fn create_group_record(
     context: &Context,
     grpid: impl AsRef<str>,
-    grpname: *const libc::c_char,
+    grpname: impl AsRef<str>,
     create_blocked: Blocked,
     create_verified: VerifiedStatus,
 ) -> u32 {
@@ -1621,7 +1518,7 @@ fn create_group_record(
             } else {
                 Chattype::Group
             },
-            as_str(grpname),
+            grpname.as_ref(),
             grpid.as_ref(),
             create_blocked,
         ],
@@ -1744,7 +1641,7 @@ fn search_chat_ids_by_contact_ids(context: &Context, unsorted_contact_ids: &Vec<
 
 unsafe fn check_verified_properties(
     context: &Context,
-    mimeparser: &dc_mimeparser_t,
+    mimeparser: &MimeParser,
     from_id: u32,
     to_ids: &Vec<u32>,
     failure_reason: *mut *mut libc::c_char,
@@ -1844,46 +1741,54 @@ unsafe fn check_verified_properties(
     1
 }
 
-unsafe fn set_better_msg<T: AsRef<str>>(mime_parser: &mut dc_mimeparser_t, better_msg: T) {
+fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {
     let msg = better_msg.as_ref();
     if msg.len() > 0 && !mime_parser.parts.is_empty() {
         let part = &mut mime_parser.parts[0];
-        if (*part).type_0 == Viewtype::Text {
+        if part.typ == Viewtype::Text {
             part.msg = Some(msg.to_string());
         }
     };
 }
 
-unsafe fn dc_is_reply_to_known_message(
-    context: &Context,
-    mime_parser: &dc_mimeparser_t,
-) -> libc::c_int {
+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) or from `Chat-Predecessor:` (Delta clients, see comment in dc_chat.c) */
-    let optional_field = dc_mimeparser_lookup_optional_field(mime_parser, "Chat-Predecessor");
-    if !optional_field.is_null() {
-        if 0 != is_known_rfc724_mid(context, (*optional_field).fld_value) {
+    if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Predecessor") {
+        let optional_field_c = CString::new(optional_field).unwrap();
+        if 0 != is_known_rfc724_mid(context, optional_field_c.as_ptr()) {
             return 1;
         }
     }
-    let field = dc_mimeparser_lookup_field(mime_parser, "In-Reply-To");
-    if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
-        let fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
-        if !fld_in_reply_to.is_null() {
-            if is_known_rfc724_mid_in_list(context, (*(*field).fld_data.fld_in_reply_to).mid_list) {
-                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 {
+            let fld_in_reply_to = (*field).fld_data.fld_in_reply_to;
+            if !fld_in_reply_to.is_null() {
+                if is_known_rfc724_mid_in_list(
+                    context,
+                    (*(*field).fld_data.fld_in_reply_to).mid_list,
+                ) {
+                    return 1;
+                }
             }
         }
     }
-    let field = dc_mimeparser_lookup_field(mime_parser, "References");
-    if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int {
-        let fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
-        if !fld_references.is_null() {
-            if is_known_rfc724_mid_in_list(context, (*(*field).fld_data.fld_references).mid_list) {
-                return 1;
+
+    if let Some(field) = mime_parser.lookup_field("References") {
+        if (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int {
+            let fld_references = (*field).fld_data.fld_references;
+            if !fld_references.is_null() {
+                if is_known_rfc724_mid_in_list(
+                    context,
+                    (*(*field).fld_data.fld_references).mid_list,
+                ) {
+                    return 1;
+                }
             }
         }
     }
+
     0
 }
 
@@ -1920,37 +1825,42 @@ fn is_known_rfc724_mid(context: &Context, rfc724_mid: *const libc::c_char) -> li
 
 unsafe fn dc_is_reply_to_messenger_message(
     context: &Context,
-    mime_parser: &dc_mimeparser_t,
+    mime_parser: &MimeParser,
 ) -> libc::c_int {
     /* function checks, if the message defined by mime_parser references a message send by us from Delta Chat.
     This is similar to is_reply_to_known_message() but
     - checks also if any of the referenced IDs are send by a messenger
     - it is okay, if the referenced messages are moved to trash here
     - no check for the Chat-* headers (function is only called if it is no messenger message itself) */
-    let field = dc_mimeparser_lookup_field(mime_parser, "In-Reply-To");
-    if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
-        let fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
-        if !fld_in_reply_to.is_null() {
-            if 0 != is_msgrmsg_rfc724_mid_in_list(
-                context,
-                (*(*field).fld_data.fld_in_reply_to).mid_list,
-            ) {
-                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 {
+            let fld_in_reply_to = (*field).fld_data.fld_in_reply_to;
+            if !fld_in_reply_to.is_null() {
+                if 0 != is_msgrmsg_rfc724_mid_in_list(
+                    context,
+                    (*(*field).fld_data.fld_in_reply_to).mid_list,
+                ) {
+                    return 1;
+                }
             }
         }
     }
-    let field = dc_mimeparser_lookup_field(mime_parser, "References");
-    if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int {
-        let fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
-        if !fld_references.is_null() {
-            if 0 != is_msgrmsg_rfc724_mid_in_list(
-                context,
-                (*(*field).fld_data.fld_references).mid_list,
-            ) {
-                return 1;
+
+    if let Some(field) = mime_parser.lookup_field("References") {
+        if (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int {
+            let fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
+            if !fld_references.is_null() {
+                if 0 != is_msgrmsg_rfc724_mid_in_list(
+                    context,
+                    (*(*field).fld_data.fld_references).mid_list,
+                ) {
+                    return 1;
+                }
             }
         }
     }
+
     0
 }
 

src/dc_simplify.rs

@@ -211,6 +211,16 @@ fn is_plain_quote(buf: &str) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        // proptest does not support [[:graphical:][:space:]] regex.
+        fn test_simplify_plain_text_fuzzy(input in "[!-~\t \n]+") {
+            let output = Simplify::new().simplify_plain_text(&input, true);
+            assert!(output.split('\n').all(|s| s != "-- "));
+        }
+    }
 
     #[test]
     fn test_simplify_trim() {

src/dc_strencode.rs

@@ -25,12 +25,15 @@ use crate::x::*;
  * @return Returns the encoded string which must be free()'d when no longed needed.
  *     On errors, NULL is returned.
  */
-pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_encode_header_words(to_encode_r: impl AsRef<str>) -> *mut libc::c_char {
+    let to_encode =
+        CString::new(to_encode_r.as_ref().as_bytes()).expect("invalid cstring to_encode");
+
     let mut ok_to_continue = true;
     let mut ret_str: *mut libc::c_char = ptr::null_mut();
-    let mut cur: *const libc::c_char = to_encode;
+    let mut cur: *const libc::c_char = to_encode.as_ptr();
     let mmapstr: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
-    if to_encode.is_null() || mmapstr.is_null() {
+    if mmapstr.is_null() {
         ok_to_continue = false;
     }
     loop {
@@ -355,12 +358,13 @@ mod tests {
             assert_eq!(CStr::from_ptr(buf1).to_str().unwrap(), "just ascii test");
             free(buf1 as *mut libc::c_void);
 
-            buf1 = dc_encode_header_words(b"abcdef\x00" as *const u8 as *const libc::c_char);
+            buf1 = dc_encode_header_words("abcdef");
             assert_eq!(CStr::from_ptr(buf1).to_str().unwrap(), "abcdef");
             free(buf1 as *mut libc::c_void);
 
             buf1 = dc_encode_header_words(
-                b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\x00" as *const u8 as *const libc::c_char,
+                std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec())
+                    .unwrap(),
             );
             assert_eq!(
                 strncmp(buf1, b"=?utf-8\x00" as *const u8 as *const libc::c_char, 7),

src/dc_tools.rs

@@ -1,12 +1,14 @@
+//! Some tools and enhancements to the used libraries, there should be
+//! no references to Context and other "larger" entities here.
+
 use std::borrow::Cow;
-use std::ffi::{CStr, CString};
-use std::path::Path;
+use std::ffi::{CStr, CString, OsString};
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::SystemTime;
 use std::{fmt, fs, ptr};
 
 use chrono::{Local, TimeZone};
-use itertools::max;
 use libc::uintptr_t;
 use mmime::clist::*;
 use mmime::mailimf_types::*;
@@ -16,10 +18,6 @@ use crate::context::Context;
 use crate::error::Error;
 use crate::x::*;
 
-/* Some tools and enhancements to the used libraries, there should be
-no references to Context and other "larger" classes here. */
-/* ** library-private **********************************************************/
-/* math tools */
 pub fn dc_exactly_one_bit_set(v: libc::c_int) -> bool {
     0 != v && 0 == v & (v - 1)
 }
@@ -570,7 +568,7 @@ fn encode_66bits_as_base64(v1: u32, v2: u32, fill: u32) -> String {
     String::from_utf8(wrapped_writer).unwrap()
 }
 
-pub unsafe fn dc_create_incoming_rfc724_mid(
+pub fn dc_create_incoming_rfc724_mid(
     message_timestamp: i64,
     contact_id_from: u32,
     contact_ids_to: &Vec<u32>,
@@ -579,51 +577,36 @@ pub unsafe fn dc_create_incoming_rfc724_mid(
         return ptr::null_mut();
     }
     /* find out the largest receiver ID (we could also take the smallest, but it should be unique) */
-    let largest_id_to = max(contact_ids_to.iter());
+    let largest_id_to = contact_ids_to.iter().max().copied().unwrap_or_default();
 
-    dc_mprintf(
-        b"%lu-%lu-%lu@stub\x00" as *const u8 as *const libc::c_char,
-        message_timestamp as libc::c_ulong,
-        contact_id_from as libc::c_ulong,
-        *largest_id_to.unwrap() as libc::c_ulong,
-    )
+    let result = format!(
+        "{}-{}-{}@stub",
+        message_timestamp, contact_id_from, largest_id_to
+    );
+
+    unsafe { result.strdup() }
 }
 
+/// Function generates a Message-ID that can be used for a new outgoing message.
+/// - this function is called for all outgoing messages.
+/// - the message ID should be globally unique
+/// - do not add a counter or any private data as as this may give unneeded information to the receiver
 pub unsafe fn dc_create_outgoing_rfc724_mid(
     grpid: *const libc::c_char,
     from_addr: *const libc::c_char,
 ) -> *mut libc::c_char {
-    /* Function generates a Message-ID that can be used for a new outgoing message.
-    - this function is called for all outgoing messages.
-    - the message ID should be globally unique
-    - do not add a counter or any private data as as this may give unneeded information to the receiver	*/
-    let mut rand1: *mut libc::c_char = ptr::null_mut();
-    let rand2: *mut libc::c_char = dc_create_id().strdup();
-    let ret: *mut libc::c_char;
-    let mut at_hostname: *const libc::c_char = strchr(from_addr, '@' as i32);
-    if at_hostname.is_null() {
-        at_hostname = b"@nohost\x00" as *const u8 as *const libc::c_char
-    }
-    if !grpid.is_null() {
-        ret = dc_mprintf(
-            b"Gr.%s.%s%s\x00" as *const u8 as *const libc::c_char,
-            grpid,
-            rand2,
-            at_hostname,
-        )
-    } else {
-        rand1 = dc_create_id().strdup();
-        ret = dc_mprintf(
-            b"Mr.%s.%s%s\x00" as *const u8 as *const libc::c_char,
-            rand1,
-            rand2,
-            at_hostname,
-        )
-    }
-    free(rand1 as *mut libc::c_void);
-    free(rand2 as *mut libc::c_void);
+    let rand2 = dc_create_id();
 
-    ret
+    let at_hostname = as_opt_str(strchr(from_addr, '@' as i32)).unwrap_or_else(|| "@nohost");
+
+    let ret = if !grpid.is_null() {
+        format!("Gr.{}.{}{}", as_str(grpid), rand2, at_hostname,)
+    } else {
+        let rand1 = dc_create_id();
+        format!("Mr.{}.{}{}", rand1, rand2, at_hostname)
+    };
+
+    ret.strdup()
 }
 
 /// Generate globally-unique message-id for a new outgoing message.
@@ -696,16 +679,6 @@ pub unsafe fn dc_extract_grpid_from_rfc724_mid_list(list: *const clist) -> *mut
     ptr::null_mut()
 }
 
-#[allow(non_snake_case)]
-unsafe fn dc_ensure_no_slash(pathNfilename: *mut libc::c_char) {
-    let path_len = strlen(pathNfilename);
-    if path_len > 0 && *pathNfilename.add(path_len - 1) as libc::c_int == '/' as i32
-        || *pathNfilename.add(path_len - 1) as libc::c_int == '\\' as i32
-    {
-        *pathNfilename.add(path_len - 1) = 0 as libc::c_char;
-    }
-}
-
 pub fn dc_ensure_no_slash_safe(path: &str) -> &str {
     if path.ends_with('/') || path.ends_with('\\') {
         return &path[..path.len() - 1];
@@ -713,18 +686,12 @@ pub fn dc_ensure_no_slash_safe(path: &str) -> &str {
     path
 }
 
-unsafe fn dc_validate_filename(filename: *mut libc::c_char) {
-    /* function modifies the given buffer and replaces all characters not valid in filenames by a "-" */
-    let mut p1: *mut libc::c_char = filename;
-    while 0 != *p1 {
-        if *p1 as libc::c_int == '/' as i32
-            || *p1 as libc::c_int == '\\' as i32
-            || *p1 as libc::c_int == ':' as i32
-        {
-            *p1 = '-' as i32 as libc::c_char
-        }
-        p1 = p1.offset(1isize)
-    }
+/// Function modifies the given buffer and replaces all characters not valid in filenames by a "-".
+fn validate_filename(filename: &str) -> String {
+    filename
+        .replace('/', "-")
+        .replace('\\', "-")
+        .replace(':', "-")
 }
 
 pub unsafe fn dc_get_filename(path_filename: impl AsRef<str>) -> *mut libc::c_char {
@@ -735,42 +702,6 @@ pub unsafe fn dc_get_filename(path_filename: impl AsRef<str>) -> *mut libc::c_ch
     }
 }
 
-// the case of the suffix is preserved
-#[allow(non_snake_case)]
-unsafe fn dc_split_filename(
-    pathNfilename: *const libc::c_char,
-    ret_basename: *mut *mut libc::c_char,
-    ret_all_suffixes_incl_dot: *mut *mut libc::c_char,
-) {
-    if pathNfilename.is_null() {
-        return;
-    }
-    /* splits a filename into basename and all suffixes, eg. "/path/foo.tar.gz" is split into "foo.tar" and ".gz",
-    (we use the _last_ dot which allows the usage inside the filename which are very usual;
-    maybe the detection could be more intelligent, however, for the moment, it is just file)
-    - if there is no suffix, the returned suffix string is empty, eg. "/path/foobar" is split into "foobar" and ""
-    - the case of the returned suffix is preserved; this is to allow reconstruction of (similar) names */
-    let basename: *mut libc::c_char = dc_get_filename(as_str(pathNfilename));
-    let suffix: *mut libc::c_char;
-    let p1: *mut libc::c_char = strrchr(basename, '.' as i32);
-    if !p1.is_null() {
-        suffix = dc_strdup(p1);
-        *p1 = 0 as libc::c_char
-    } else {
-        suffix = dc_strdup(ptr::null())
-    }
-    if !ret_basename.is_null() {
-        *ret_basename = basename
-    } else {
-        free(basename as *mut libc::c_void);
-    }
-    if !ret_all_suffixes_incl_dot.is_null() {
-        *ret_all_suffixes_incl_dot = suffix
-    } else {
-        free(suffix as *mut libc::c_void);
-    };
-}
-
 // the returned suffix is lower-case
 #[allow(non_snake_case)]
 pub unsafe fn dc_get_filesuffix_lc(path_filename: impl AsRef<str>) -> *mut libc::c_char {
@@ -876,23 +807,8 @@ pub fn dc_create_folder(context: &Context, path: impl AsRef<std::path::Path>) ->
     }
 }
 
-#[allow(non_snake_case)]
-pub unsafe fn dc_write_file(
-    context: &Context,
-    pathNfilename: *const libc::c_char,
-    buf: *const libc::c_void,
-    buf_bytes: libc::size_t,
-) -> libc::c_int {
-    let bytes = std::slice::from_raw_parts(buf as *const u8, buf_bytes);
-
-    dc_write_file_safe(context, as_str(pathNfilename), bytes) as libc::c_int
-}
-
-pub fn dc_write_file_safe<P: AsRef<std::path::Path>>(
-    context: &Context,
-    path: P,
-    buf: &[u8],
-) -> bool {
+/// Write a the given content to provied file path.
+pub fn dc_write_file(context: &Context, path: impl AsRef<Path>, buf: &[u8]) -> bool {
     let path_abs = dc_get_abs_path(context, &path);
     if let Err(_err) = fs::write(&path_abs, buf) {
         warn!(
@@ -942,58 +858,48 @@ pub fn dc_read_file_safe<P: AsRef<std::path::Path>>(context: &Context, path: P)
     }
 }
 
-#[allow(non_snake_case)]
-pub unsafe fn dc_get_fine_pathNfilename(
+pub fn dc_get_fine_path_filename(
     context: &Context,
-    pathNfolder: *const libc::c_char,
-    desired_filenameNsuffix__: *const libc::c_char,
-) -> *mut libc::c_char {
-    let mut ret: *mut libc::c_char = ptr::null_mut();
-    let pathNfolder_wo_slash: *mut libc::c_char;
-    let filenameNsuffix: *mut libc::c_char;
-    let mut basename: *mut libc::c_char = ptr::null_mut();
-    let mut dotNSuffix: *mut libc::c_char = ptr::null_mut();
+    folder: impl AsRef<Path>,
+    desired_filename_suffix: impl AsRef<str>,
+) -> PathBuf {
     let now = time();
 
-    pathNfolder_wo_slash = dc_strdup(pathNfolder);
-    dc_ensure_no_slash(pathNfolder_wo_slash);
-    filenameNsuffix = dc_strdup(desired_filenameNsuffix__);
-    dc_validate_filename(filenameNsuffix);
-    dc_split_filename(filenameNsuffix, &mut basename, &mut dotNSuffix);
+    let folder = PathBuf::from(folder.as_ref());
+    let suffix = validate_filename(desired_filename_suffix.as_ref());
 
-    for i in 0..1000i64 {
-        /*no deadlocks, please*/
-        if 0 != i {
-            let idx = if i < 100 { i } else { now + i };
-            ret = dc_mprintf(
-                b"%s/%s-%lu%s\x00" as *const u8 as *const libc::c_char,
-                pathNfolder_wo_slash,
-                basename,
-                idx as libc::c_ulong,
-                dotNSuffix,
-            )
+    let file_name = PathBuf::from(suffix);
+    let extension = file_name.extension().map(|c| c.clone());
+
+    for i in 0..100_000 {
+        let ret = if i == 0 {
+            let mut folder = folder.clone();
+            folder.push(&file_name);
+            folder
         } else {
-            ret = dc_mprintf(
-                b"%s/%s%s\x00" as *const u8 as *const libc::c_char,
-                pathNfolder_wo_slash,
-                basename,
-                dotNSuffix,
-            )
+            let idx = if i < 100 { i } else { now + i };
+            let file_name = if let Some(stem) = file_name.file_stem() {
+                let mut stem = stem.to_os_string();
+                stem.push(format!("-{}", idx));
+                stem
+            } else {
+                OsString::from(idx.to_string())
+            };
+            let mut folder = folder.clone();
+            folder.push(file_name);
+            if let Some(ext) = extension {
+                folder.set_extension(&ext);
+            }
+            folder
+        };
+
+        if !dc_file_exist(context, &ret) {
+            // fine filename found
+            return ret;
         }
-        if !dc_file_exist(context, as_path(ret)) {
-            /* fine filename found */
-            break;
-        }
-        free(ret as *mut libc::c_void);
-        ret = ptr::null_mut();
     }
 
-    free(filenameNsuffix as *mut libc::c_void);
-    free(basename as *mut libc::c_void);
-    free(dotNSuffix as *mut libc::c_void);
-    free(pathNfolder_wo_slash as *mut libc::c_void);
-
-    ret
+    panic!("Something is really wrong, you need to clean up your disk");
 }
 
 pub fn dc_is_blobdir_path(context: &Context, path: impl AsRef<str>) -> bool {
@@ -1017,38 +923,18 @@ fn dc_make_rel_path(context: &Context, path: &mut String) {
 }
 
 pub fn dc_make_rel_and_copy(context: &Context, path: &mut String) -> bool {
-    let mut success = false;
-    let mut filename = ptr::null_mut();
-    let mut blobdir_path = ptr::null_mut();
     if dc_is_blobdir_path(context, &path) {
         dc_make_rel_path(context, path);
-        success = true;
-    } else {
-        filename = unsafe { dc_get_filename(&path) };
-        if !(filename.is_null()
-            || {
-                blobdir_path = unsafe {
-                    dc_get_fine_pathNfilename(
-                        context,
-                        b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
-                        filename,
-                    )
-                };
-                blobdir_path.is_null()
-            }
-            || !dc_copy_file(context, &path, as_path(blobdir_path)))
-        {
-            *path = to_string(blobdir_path);
-            blobdir_path = ptr::null_mut();
-            dc_make_rel_path(context, path);
-            success = true;
-        }
+        return true;
     }
-    unsafe {
-        free(blobdir_path.cast());
-        free(filename.cast());
+    let blobdir_path = dc_get_fine_path_filename(context, "$BLOBDIR", &path);
+    if dc_copy_file(context, &path, &blobdir_path) {
+        *path = blobdir_path.to_string_lossy().to_string();
+        dc_make_rel_path(context, path);
+        return true;
     }
-    success
+
+    false
 }
 
 /// Error type for the [OsStrExt] trait
@@ -1923,4 +1809,14 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_dc_create_incoming_rfc724_mid() {
+        let res = dc_create_incoming_rfc724_mid(123, 45, &vec![6, 7]);
+        assert_eq!(as_str(res), "123-45-7@stub");
+
+        unsafe {
+            free(res.cast());
+        }
+    }
 }

src/e2ee.rs

@@ -296,7 +296,7 @@ impl E2eeHelper {
                             if (*plain).str_0.is_null() || (*plain).len <= 0 {
                                 ok_to_continue = false;
                             } else {
-                                if let Some(ctext_v) = dc_pgp_pk_encrypt(
+                                if let Ok(ctext_v) = dc_pgp_pk_encrypt(
                                     std::slice::from_raw_parts(
                                         (*plain).str_0 as *const u8,
                                         (*plain).len,
@@ -386,16 +386,17 @@ impl E2eeHelper {
         /*just a pointer into mailmime structure, must not be freed*/
         let imffields: *mut mailimf_fields = mailmime_find_mailimf_fields(in_out_message);
         let mut message_time = 0;
-        let mut from: *mut libc::c_char = ptr::null_mut();
+        let mut from = None;
         let mut private_keyring = Keyring::default();
         let mut public_keyring_for_validate = Keyring::default();
         let mut gossip_headers: *mut mailimf_fields = ptr::null_mut();
         if !(in_out_message.is_null() || imffields.is_null()) {
-            let mut field: *mut mailimf_field =
-                mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
+            let mut field = mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
+
             if !field.is_null() && !(*field).fld_data.fld_from.is_null() {
                 from = mailimf_find_first_addr((*(*field).fld_data.fld_from).frm_mb_list)
             }
+
             field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
             if !field.is_null() && !(*field).fld_data.fld_orig_date.is_null() {
                 let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
@@ -407,25 +408,28 @@ impl E2eeHelper {
                 }
             }
             let mut peerstate = None;
-            let autocryptheader =
-                as_opt_str(from).and_then(|from| Aheader::from_imffields(from, imffields));
-            if message_time > 0 && !from.is_null() {
-                peerstate = Peerstate::from_addr(context, &context.sql, as_str(from));
+            let autocryptheader = from
+                .as_ref()
+                .and_then(|from| Aheader::from_imffields(from, imffields));
+            if message_time > 0 {
+                if let Some(ref from) = from {
+                    peerstate = Peerstate::from_addr(context, &context.sql, from);
 
-                if let Some(ref mut peerstate) = peerstate {
-                    if let Some(ref header) = autocryptheader {
-                        peerstate.apply_header(&header, message_time);
-                        peerstate.save_to_db(&context.sql, false);
-                    } else if message_time > peerstate.last_seen_autocrypt
-                        && !contains_report(in_out_message)
-                    {
-                        peerstate.degrade_encryption(message_time);
-                        peerstate.save_to_db(&context.sql, false);
+                    if let Some(ref mut peerstate) = peerstate {
+                        if let Some(ref header) = autocryptheader {
+                            peerstate.apply_header(&header, message_time);
+                            peerstate.save_to_db(&context.sql, false);
+                        } else if message_time > peerstate.last_seen_autocrypt
+                            && !contains_report(in_out_message)
+                        {
+                            peerstate.degrade_encryption(message_time);
+                            peerstate.save_to_db(&context.sql, false);
+                        }
+                    } else if let Some(ref header) = autocryptheader {
+                        let p = Peerstate::from_header(context, header, message_time);
+                        assert!(p.save_to_db(&context.sql, true));
+                        peerstate = Some(p);
                     }
-                } else if let Some(ref header) = autocryptheader {
-                    let p = Peerstate::from_header(context, header, message_time);
-                    assert!(p.save_to_db(&context.sql, true));
-                    peerstate = Some(p);
                 }
             }
             /* load private key for decryption */
@@ -437,7 +441,8 @@ impl E2eeHelper {
                     &context.sql,
                 ) {
                     if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 {
-                        peerstate = Peerstate::from_addr(&context, &context.sql, as_str(from));
+                        peerstate =
+                            Peerstate::from_addr(&context, &context.sql, &from.unwrap_or_default());
                     }
                     if let Some(ref peerstate) = peerstate {
                         if peerstate.degrade_event.is_some() {
@@ -486,8 +491,6 @@ impl E2eeHelper {
         if !gossip_headers.is_null() {
             mailimf_fields_free(gossip_headers);
         }
-
-        free(from as *mut libc::c_void);
     }
 }
 
@@ -905,7 +908,7 @@ unsafe fn decrypt_part(
                 };
 
                 /*if we already have fingerprints, do not add more; this ensures, only the fingerprints from the outer-most part are collected */
-                if let Some(plain) = dc_pgp_pk_decrypt(
+                if let Ok(plain) = dc_pgp_pk_decrypt(
                     std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes),
                     &private_keyring,
                     &public_keyring_for_validate,

src/error.rs

@@ -24,6 +24,8 @@ pub enum Error {
     Utf8(std::str::Utf8Error),
     #[fail(display = "{:?}", _0)]
     CStringError(crate::dc_tools::CStringError),
+    #[fail(display = "PGP: {:?}", _0)]
+    Pgp(pgp::errors::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -70,6 +72,12 @@ impl From<crate::dc_tools::CStringError> for Error {
     }
 }
 
+impl From<pgp::errors::Error> for Error {
+    fn from(err: pgp::errors::Error) -> Error {
+        Error::Pgp(err)
+    }
+}
+
 #[macro_export]
 macro_rules! bail {
     ($e:expr) => {

src/imap.rs

@@ -20,7 +20,6 @@ use crate::oauth2::dc_get_oauth2_access_token;
 use crate::param::Params;
 
 const DC_IMAP_SEEN: usize = 0x0001;
-const DC_REGENERATE: usize = 0x01;
 
 const DC_SUCCESS: usize = 3;
 const DC_ALREADY_DONE: usize = 2;
@@ -418,9 +417,7 @@ impl Imap {
                 if (server_flags & DC_LP_AUTH_OAUTH2) != 0 {
                     let addr: &str = config.addr.as_ref();
 
-                    if let Some(token) =
-                        dc_get_oauth2_access_token(context, addr, imap_pw, DC_REGENERATE as usize)
-                    {
+                    if let Some(token) = dc_get_oauth2_access_token(context, addr, imap_pw, true) {
                         let auth = OAuth2 {
                             user: imap_user.into(),
                             access_token: token,

src/job.rs

@@ -998,38 +998,23 @@ fn send_mdn(context: &Context, msg_id: u32) {
 
 #[allow(non_snake_case)]
 fn add_smtp_job(context: &Context, action: Action, mimefactory: &dc_mimefactory_t) -> libc::c_int {
-    let pathNfilename: *mut libc::c_char;
     let mut success: libc::c_int = 0i32;
     let mut recipients: *mut libc::c_char = ptr::null_mut();
     let mut param = Params::new();
-    pathNfilename = unsafe {
-        dc_get_fine_pathNfilename(
-            context,
-            b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
-            mimefactory.rfc724_mid,
+    let path_filename =
+        dc_get_fine_path_filename(context, "$BLOBDIR", as_str(mimefactory.rfc724_mid));
+    let bytes = unsafe {
+        std::slice::from_raw_parts(
+            (*mimefactory.out).str_0 as *const u8,
+            (*mimefactory.out).len,
         )
     };
-    if pathNfilename.is_null() {
-        error!(
-            context,
-            "Could not find free file name for message with ID <{}>.",
-            to_string(mimefactory.rfc724_mid),
-        );
-    } else if 0
-        == unsafe {
-            dc_write_file(
-                context,
-                pathNfilename,
-                (*mimefactory.out).str_0 as *const libc::c_void,
-                (*mimefactory.out).len,
-            )
-        }
-    {
+    if !dc_write_file(context, &path_filename, bytes) {
         error!(
             context,
             "Could not write message <{}> to \"{}\".",
             to_string(mimefactory.rfc724_mid),
-            as_str(pathNfilename),
+            path_filename.display(),
         );
     } else {
         recipients = unsafe {
@@ -1038,7 +1023,7 @@ fn add_smtp_job(context: &Context, action: Action, mimefactory: &dc_mimefactory_
                 b"\x1e\x00" as *const u8 as *const libc::c_char,
             )
         };
-        param.set(Param::File, as_str(pathNfilename));
+        param.set(Param::File, path_filename.to_string_lossy());
         param.set(Param::Recipients, as_str(recipients));
         job_add(
             context,
@@ -1057,7 +1042,6 @@ fn add_smtp_job(context: &Context, action: Action, mimefactory: &dc_mimefactory_
     }
     unsafe {
         free(recipients.cast());
-        free(pathNfilename.cast());
     }
     success
 }

src/key.rs

@@ -218,7 +218,7 @@ impl Key {
     pub fn write_asc_to_file(&self, file: impl AsRef<Path>, context: &Context) -> bool {
         let file_content = self.to_asc(None).into_bytes();
 
-        if dc_write_file_safe(context, &file, &file_content) {
+        if dc_write_file(context, &file, &file_content) {
             return true;
         } else {
             error!(context, "Cannot write key to {}", file.as_ref().display());

src/message.rs

@@ -9,6 +9,7 @@ use crate::chat::{self, Chat};
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::*;
+use crate::dc_mimeparser::SystemMessage;
 use crate::dc_tools::*;
 use crate::error::Error;
 use crate::events::Event;
@@ -767,7 +768,7 @@ pub fn dc_msg_get_summarytext_by_raw(
         Viewtype::Video => context.stock_str(StockMessage::Video).into_owned(),
         Viewtype::Voice => context.stock_str(StockMessage::VoiceMessage).into_owned(),
         Viewtype::Audio | Viewtype::File => {
-            if param.get_int(Param::Cmd) == Some(6) {
+            if param.get_cmd() == SystemMessage::AutocryptSetupMessage {
                 append_text = false;
                 context
                     .stock_str(StockMessage::AcSetupMsgSubject)
@@ -793,7 +794,7 @@ pub fn dc_msg_get_summarytext_by_raw(
             }
         }
         _ => {
-            if param.get_int(Param::Cmd) != Some(9) {
+            if param.get_cmd() != SystemMessage::LocationOnly {
                 "".to_string()
             } else {
                 append_text = false;
@@ -839,10 +840,10 @@ pub fn dc_msg_is_forwarded(msg: &Message) -> bool {
 }
 
 pub fn dc_msg_is_info(msg: &Message) -> bool {
-    let cmd = msg.param.get_int(Param::Cmd).unwrap_or_default();
+    let cmd = msg.param.get_cmd();
     msg.from_id == 2i32 as libc::c_uint
         || msg.to_id == 2i32 as libc::c_uint
-        || 0 != cmd && cmd != 6i32
+        || cmd != SystemMessage::Unknown && cmd != SystemMessage::AutocryptSetupMessage
 }
 
 pub fn dc_msg_is_increation(msg: &Message) -> bool {
@@ -854,7 +855,7 @@ pub fn dc_msg_is_setupmessage(msg: &Message) -> bool {
         return false;
     }
 
-    msg.param.get_int(Param::Cmd) == Some(6)
+    msg.param.get_cmd() == SystemMessage::AutocryptSetupMessage
 }
 
 pub unsafe fn dc_msg_get_setupcodebegin(context: &Context, msg: &Message) -> *mut libc::c_char {

src/oauth2.rs

@@ -74,14 +74,14 @@ pub fn dc_get_oauth2_access_token(
     context: &Context,
     addr: impl AsRef<str>,
     code: impl AsRef<str>,
-    flags: usize,
+    regenerate: bool,
 ) -> Option<String> {
     if let Some(oauth2) = Oauth2::from_address(addr) {
         let lock = context.oauth2_critical.clone();
         let _l = lock.lock().unwrap();
 
         // read generated token
-        if 0 == flags & 0x1 && !is_expired(context) {
+        if !regenerate && !is_expired(context) {
             let access_token = context.sql.get_config(context, "oauth2_access_token");
             if access_token.is_some() {
                 // success
@@ -216,12 +216,13 @@ pub fn dc_get_oauth2_addr(
         return None;
     }
 
-    if let Some(access_token) = dc_get_oauth2_access_token(context, addr.as_ref(), code.as_ref(), 0)
+    if let Some(access_token) =
+        dc_get_oauth2_access_token(context, addr.as_ref(), code.as_ref(), false)
     {
         let addr_out = oauth2.get_addr(context, access_token);
         if addr_out.is_none() {
             // regenerate
-            if let Some(access_token) = dc_get_oauth2_access_token(context, addr, code, 0x1) {
+            if let Some(access_token) = dc_get_oauth2_access_token(context, addr, code, true) {
                 oauth2.get_addr(context, access_token)
             } else {
                 None

src/param.rs

@@ -4,6 +4,7 @@ use std::str;
 
 use num_traits::FromPrimitive;
 
+use crate::dc_mimeparser::SystemMessage;
 use crate::error;
 
 /// Available param keys.
@@ -178,6 +179,13 @@ impl Params {
         self.get(key).and_then(|s| s.parse().ok())
     }
 
+    /// Get the parameter behind `Param::Cmd` interpreted as `SystemMessage`.
+    pub fn get_cmd(&self) -> SystemMessage {
+        self.get_int(Param::Cmd)
+            .and_then(SystemMessage::from_i32)
+            .unwrap_or_default()
+    }
+
     /// Get the given parameter and parse as `f64`.
     pub fn get_float(&self, key: Param) -> Option<f64> {
         self.get(key).and_then(|s| s.parse().ok())

src/peerstate.rs

@@ -499,7 +499,11 @@ mod tests {
         let ctx = crate::test_utils::dummy_context();
         let addr = "hello@mail.com";
 
-        let pub_key = crate::key::Key::from_base64("xsBNBFztUVkBCADYaQl/UOUpRPd32nLRzx8eU0eI+jQEnG+g5anjYA+3oct1rROGl5SygjMULDKdaUy27O3o9Srsti0YjA7uxZnavIqhSopJhFidqY1M1wA9JZa/duucZdNwUGbjGIRsS/4Cjr5+3svscK24hVYub1dvDWXpwUTnj3K6xOEnJdoM+MhCqtSD5+zcJhFc9vyZm9ZTGWUxAhKh0iJTcCD8V6CQ3XZ2z9GruwzZT/FTFovWrz7m3TUI2OdSSHh0eZLRGEoxMCT/vzflAFGAr8ijCaRsEIfqP6FW8uQWnFTqkjxEUCZG6XkeFHB84aj5jqYG/1KCLjL5vEKwfl1tz/WnPhY7ABEBAAHNEDxoZWxsb0BtYWlsLmNvbT7CwIkEEAEIADMCGQEFAlztUVoCGwMECwkIBwYVCAkKCwIDFgIBFiEEgMjHGVbvLXe6ioRROg8oKCvye7gACgkQOg8oKCvye7ijAwf+PTsuawUax9cNPn1bN90H+g9qyHZJMEwKXtUnNaXJxPW3iB7ThhpCiCzsZwP7+l7ArS8tmLeNDw2bENtcf1XCv4wovP2fdXOP3QOUUFX/GdakcTwv7DzC7CO0grB1HtaPhGw/6UX2o2cx2i9xiUf4Givq2MfCbgAW5zloH6WXGPb6yLQYJXxqDIphr4+uZDb+bMAyWHN/DUkAjHrV8nnVki7PMHqzzZpwglalxMX8RGeiGZE39ALJKL/Og87DMFah87/yoxQWGoS7Wqv0XDcCPKoTCPrpk8pOe2KEsq/lz215nefHd4aRpfUX5YCYa8HPvvfPQbGF73uvyQw5w7qjis7ATQRc7VFZAQgAt8ONdnX6KEEQ5Jw6ilJ+LBtY44SP5t0I3eK+goKepgIiKhjGDa+Mntyi4jdhH+HO6kvK5SHMh2sPp4rRO/WKHJwWFySyM1OdyiywhyH0J9R5rBY4vPHsJjf6vSKJdWLWT+ho1fNet2IIC+jVCYli91MAMbRvk6EKVj1nCc+67giOahXEkHt6xxkeCGlOvbw8hxGj1A8+AC1BLms/OR3oc4JMi9O3kq6uG0z9tlUEerac9HVwcjoO1XLe+hJhoT5H+TbnGjPuhuURP3pFiIKHpbRYgUfdSAY0dTObO7t4I5y/drPOrCTnWrBUg2wXAECUhpRKow9/ai2YemLv9KqhhwARAQABwsB2BBgBCAAgBQJc7VFaAhsMFiEEgMjHGVbvLXe6ioRROg8oKCvye7gACgkQOg8oKCvye7jmyggAhs4QzCzIbT2OsAReBxkxtm0AI+g1HZ1KFKof5NDHfgv9C/Qu1I8mKEjlZzA4qFyPmLqntgwJ0RuFy6gLbljZBNCFO7vB478AhYtnWjuKZmA40HUPwcB1hEJ31c42akzfUbioY1TLLepngdsJg7Cm8O+rhI9+1WRA66haJDgFs793SVUDyJh8f9NX50l5zR87/bsV30CFSw0q4OSSy9VI/z+2g5khn1LnuuOrCfFnYIPYtJED1BfkXkosxGlgbzy79VvGmI9d23x4atDK7oBPCzIj+lP8sytJ0u3HOguXi9OgDitKy+Pt1r8gH8frdktMJr5Ts6DW+tIn2vR23KR8aA==", KeyType::Public).unwrap();
+        let pub_key = crate::key::Key::from_base64(
+            include_str!("../test-data/key/public.asc"),
+            KeyType::Public,
+        )
+        .unwrap();
 
         let mut peerstate = Peerstate {
             context: &ctx.ctx,
@@ -537,7 +541,11 @@ mod tests {
         let ctx = crate::test_utils::dummy_context();
         let addr = "hello@mail.com";
 
-        let pub_key = crate::key::Key::from_base64("xsBNBFztUVkBCADYaQl/UOUpRPd32nLRzx8eU0eI+jQEnG+g5anjYA+3oct1rROGl5SygjMULDKdaUy27O3o9Srsti0YjA7uxZnavIqhSopJhFidqY1M1wA9JZa/duucZdNwUGbjGIRsS/4Cjr5+3svscK24hVYub1dvDWXpwUTnj3K6xOEnJdoM+MhCqtSD5+zcJhFc9vyZm9ZTGWUxAhKh0iJTcCD8V6CQ3XZ2z9GruwzZT/FTFovWrz7m3TUI2OdSSHh0eZLRGEoxMCT/vzflAFGAr8ijCaRsEIfqP6FW8uQWnFTqkjxEUCZG6XkeFHB84aj5jqYG/1KCLjL5vEKwfl1tz/WnPhY7ABEBAAHNEDxoZWxsb0BtYWlsLmNvbT7CwIkEEAEIADMCGQEFAlztUVoCGwMECwkIBwYVCAkKCwIDFgIBFiEEgMjHGVbvLXe6ioRROg8oKCvye7gACgkQOg8oKCvye7ijAwf+PTsuawUax9cNPn1bN90H+g9qyHZJMEwKXtUnNaXJxPW3iB7ThhpCiCzsZwP7+l7ArS8tmLeNDw2bENtcf1XCv4wovP2fdXOP3QOUUFX/GdakcTwv7DzC7CO0grB1HtaPhGw/6UX2o2cx2i9xiUf4Givq2MfCbgAW5zloH6WXGPb6yLQYJXxqDIphr4+uZDb+bMAyWHN/DUkAjHrV8nnVki7PMHqzzZpwglalxMX8RGeiGZE39ALJKL/Og87DMFah87/yoxQWGoS7Wqv0XDcCPKoTCPrpk8pOe2KEsq/lz215nefHd4aRpfUX5YCYa8HPvvfPQbGF73uvyQw5w7qjis7ATQRc7VFZAQgAt8ONdnX6KEEQ5Jw6ilJ+LBtY44SP5t0I3eK+goKepgIiKhjGDa+Mntyi4jdhH+HO6kvK5SHMh2sPp4rRO/WKHJwWFySyM1OdyiywhyH0J9R5rBY4vPHsJjf6vSKJdWLWT+ho1fNet2IIC+jVCYli91MAMbRvk6EKVj1nCc+67giOahXEkHt6xxkeCGlOvbw8hxGj1A8+AC1BLms/OR3oc4JMi9O3kq6uG0z9tlUEerac9HVwcjoO1XLe+hJhoT5H+TbnGjPuhuURP3pFiIKHpbRYgUfdSAY0dTObO7t4I5y/drPOrCTnWrBUg2wXAECUhpRKow9/ai2YemLv9KqhhwARAQABwsB2BBgBCAAgBQJc7VFaAhsMFiEEgMjHGVbvLXe6ioRROg8oKCvye7gACgkQOg8oKCvye7jmyggAhs4QzCzIbT2OsAReBxkxtm0AI+g1HZ1KFKof5NDHfgv9C/Qu1I8mKEjlZzA4qFyPmLqntgwJ0RuFy6gLbljZBNCFO7vB478AhYtnWjuKZmA40HUPwcB1hEJ31c42akzfUbioY1TLLepngdsJg7Cm8O+rhI9+1WRA66haJDgFs793SVUDyJh8f9NX50l5zR87/bsV30CFSw0q4OSSy9VI/z+2g5khn1LnuuOrCfFnYIPYtJED1BfkXkosxGlgbzy79VvGmI9d23x4atDK7oBPCzIj+lP8sytJ0u3HOguXi9OgDitKy+Pt1r8gH8frdktMJr5Ts6DW+tIn2vR23KR8aA==", KeyType::Public).unwrap();
+        let pub_key = crate::key::Key::from_base64(
+            include_str!("../test-data/key/public.asc"),
+            KeyType::Public,
+        )
+        .unwrap();
 
         let mut peerstate = Peerstate {
             context: &ctx.ctx,

src/pgp.rs

@@ -12,6 +12,7 @@ use pgp::types::{CompressionAlgorithm, KeyTrait, SecretKeyTrait, StringToKey};
 use rand::thread_rng;
 
 use crate::dc_tools::*;
+use crate::error::Error;
 use crate::key::*;
 use crate::keyring::*;
 use crate::x::*;
@@ -189,7 +190,7 @@ pub fn dc_pgp_pk_encrypt(
     plain: &[u8],
     public_keys_for_encryption: &Keyring,
     private_key_for_signing: Option<&Key>,
-) -> Option<String> {
+) -> Result<String, Error> {
     let lit_msg = Message::new_literal_bytes("", plain);
     let pkeys: Vec<&SignedPublicKey> = public_keys_for_encryption
         .keys()
@@ -203,9 +204,10 @@ pub fn dc_pgp_pk_encrypt(
     let mut rng = thread_rng();
 
     // TODO: measure time
-    // TODO: better error handling
     let encrypted_msg = if let Some(private_key) = private_key_for_signing {
-        let skey: &SignedSecretKey = private_key.try_into().unwrap();
+        let skey: &SignedSecretKey = private_key
+            .try_into()
+            .map_err(|_| format_err!("Invalid private key"))?;
 
         lit_msg
             .sign(skey, || "".into(), Default::default())
@@ -215,9 +217,10 @@ pub fn dc_pgp_pk_encrypt(
         lit_msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys)
     };
 
-    encrypted_msg
-        .and_then(|msg| msg.to_armored_string(None))
-        .ok()
+    let msg = encrypted_msg?;
+    let encoded_msg = msg.to_armored_string(None)?;
+
+    Ok(encoded_msg)
 }
 
 pub fn dc_pgp_pk_decrypt(
@@ -225,76 +228,73 @@ pub fn dc_pgp_pk_decrypt(
     private_keys_for_decryption: &Keyring,
     public_keys_for_validation: &Keyring,
     ret_signature_fingerprints: Option<&mut HashSet<String>>,
-) -> Option<Vec<u8>> {
-    // TODO: proper error handling
-    if let Ok((msg, _)) = Message::from_armor_single(Cursor::new(ctext)) {
-        let skeys: Vec<&SignedSecretKey> = private_keys_for_decryption
-            .keys()
-            .iter()
-            .filter_map(|key| {
-                let k: &Key = &key;
-                k.try_into().ok()
-            })
-            .collect();
+) -> Result<Vec<u8>, Error> {
+    let (msg, _) = Message::from_armor_single(Cursor::new(ctext))?;
+    let skeys: Vec<&SignedSecretKey> = private_keys_for_decryption
+        .keys()
+        .iter()
+        .filter_map(|key| {
+            let k: &Key = &key;
+            k.try_into().ok()
+        })
+        .collect();
 
-        msg.decrypt(|| "".into(), || "".into(), &skeys[..])
-            .and_then(|(mut decryptor, _)| {
-                // TODO: how to handle the case when we detect multiple messages?
-                decryptor.next().expect("no message")
-            })
-            .and_then(|dec_msg| {
-                if let Some(ret_signature_fingerprints) = ret_signature_fingerprints {
-                    if !public_keys_for_validation.keys().is_empty() {
-                        let pkeys: Vec<&SignedPublicKey> = public_keys_for_validation
-                            .keys()
-                            .iter()
-                            .filter_map(|key| {
-                                let k: &Key = &key;
-                                k.try_into().ok()
-                            })
-                            .collect();
+    let (decryptor, _) = msg.decrypt(|| "".into(), || "".into(), &skeys[..])?;
+    let msgs = decryptor.collect::<Result<Vec<_>, _>>()?;
+    ensure!(!msgs.is_empty(), "No valid messages found");
 
-                        for pkey in &pkeys {
-                            if dec_msg.verify(&pkey.primary_key).is_ok() {
-                                let fp = hex::encode_upper(pkey.fingerprint());
-                                ret_signature_fingerprints.insert(fp);
-                            }
-                        }
-                    }
+    let dec_msg = &msgs[0];
+
+    if let Some(ret_signature_fingerprints) = ret_signature_fingerprints {
+        if !public_keys_for_validation.keys().is_empty() {
+            let pkeys: Vec<&SignedPublicKey> = public_keys_for_validation
+                .keys()
+                .iter()
+                .filter_map(|key| {
+                    let k: &Key = &key;
+                    k.try_into().ok()
+                })
+                .collect();
+
+            for pkey in &pkeys {
+                if dec_msg.verify(&pkey.primary_key).is_ok() {
+                    let fp = hex::encode_upper(pkey.fingerprint());
+                    ret_signature_fingerprints.insert(fp);
                 }
-                dec_msg.get_content()
-            })
-            .ok()
-            .and_then(|content| content)
-    } else {
-        None
+            }
+        }
+    }
+
+    match dec_msg.get_content()? {
+        Some(content) => Ok(content),
+        None => bail!("Decrypted message is empty"),
     }
 }
 
 /// Symmetric encryption.
-pub fn dc_pgp_symm_encrypt(passphrase: &str, plain: &[u8]) -> Option<String> {
+pub fn dc_pgp_symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String, Error> {
     let mut rng = thread_rng();
     let lit_msg = Message::new_literal_bytes("", plain);
 
     let s2k = StringToKey::new_default(&mut rng);
     let msg =
-        lit_msg.encrypt_with_password(&mut rng, s2k, Default::default(), || passphrase.into());
+        lit_msg.encrypt_with_password(&mut rng, s2k, Default::default(), || passphrase.into())?;
 
-    msg.and_then(|msg| msg.to_armored_string(None)).ok()
+    let encoded_msg = msg.to_armored_string(None)?;
+
+    Ok(encoded_msg)
 }
 
 /// Symmetric decryption.
-pub fn dc_pgp_symm_decrypt(passphrase: &str, ctext: &[u8]) -> Option<Vec<u8>> {
-    let enc_msg = Message::from_bytes(Cursor::new(ctext));
+pub fn dc_pgp_symm_decrypt(passphrase: &str, ctext: &[u8]) -> Result<Vec<u8>, Error> {
+    let enc_msg = Message::from_bytes(Cursor::new(ctext))?;
+    let decryptor = enc_msg.decrypt_with_password(|| passphrase.into())?;
 
-    enc_msg
-        .and_then(|msg| {
-            let mut decryptor = msg
-                .decrypt_with_password(|| passphrase.into())
-                .expect("failed decryption");
-            decryptor.next().expect("no message")
-        })
-        .and_then(|msg| msg.get_content())
-        .ok()
-        .and_then(|content| content)
+    let msgs = decryptor.collect::<Result<Vec<_>, _>>()?;
+    ensure!(!msgs.is_empty(), "No valid messages found");
+
+    match msgs[0].get_content()? {
+        Some(content) => Ok(content),
+        None => bail!("Decrypted message is empty"),
+    }
 }

src/qr.rs

@@ -70,19 +70,14 @@ fn decode_openpgp(context: &Context, qr: &str) -> Lot {
         None => return format_err!("Invalid OPENPGP4FPR found").into(),
     };
 
-    dbg!(fingerprint);
-    dbg!(fragment);
-
     // replace & with \n to match expected param format
     let fragment = fragment.replace('&', "\n");
-    dbg!(&fragment);
 
     // Then parse the parameters
     let param: Params = match fragment.parse() {
         Ok(params) => params,
         Err(err) => return err.into(),
     };
-    dbg!(&param);
 
     let addr = if let Some(addr) = param.get(Param::Forwarded) {
         match normalize_address(addr) {

src/securejoin.rs

@@ -1,6 +1,4 @@
-use mmime::mailimf_types::*;
 use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};
-use std::ptr;
 
 use crate::aheader::EncryptPreference;
 use crate::chat::{self, Chat};
@@ -10,7 +8,6 @@ use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
 use crate::dc_mimeparser::*;
-use crate::dc_tools::*;
 use crate::e2ee::*;
 use crate::error::Error;
 use crate::events::Event;
@@ -335,7 +332,7 @@ fn fingerprint_equals_sender(
 /* library private: secure-join */
 pub fn handle_securejoin_handshake(
     context: &Context,
-    mimeparser: &dc_mimeparser_t,
+    mimeparser: &MimeParser,
     contact_id: u32,
 ) -> libc::c_int {
     let own_fingerprint: String;
@@ -343,7 +340,7 @@ pub fn handle_securejoin_handshake(
     if contact_id <= DC_CONTACT_ID_LAST_SPECIAL {
         return 0;
     }
-    let step = match lookup_field(mimeparser, "Secure-Join") {
+    let step = match mimeparser.lookup_optional_field("Secure-Join") {
         Some(s) => s,
         None => {
             return 0;
@@ -372,7 +369,7 @@ pub fn handle_securejoin_handshake(
             // it just ensures, we have Bobs key now. If we do _not_ have the key because eg. MitM has removed it,
             // send_message() will fail with the error "End-to-end-encryption unavailable unexpectedly.", so, there is no additional check needed here.
             // verify that the `Secure-Join-Invitenumber:`-header matches invitenumber written to the QR code
-            let invitenumber = match lookup_field(mimeparser, "Secure-Join-Invitenumber") {
+            let invitenumber = match mimeparser.lookup_optional_field("Secure-Join-Invitenumber") {
                 Some(n) => n,
                 None => {
                     warn!(context, "Secure-join denied (invitenumber missing).",);
@@ -459,7 +456,7 @@ pub fn handle_securejoin_handshake(
             ====  Step 6 in "Out-of-band verified groups" protocol  ====
             ============================================================ */
             // verify that Secure-Join-Fingerprint:-header matches the fingerprint of Bob
-            let fingerprint = match lookup_field(mimeparser, "Secure-Join-Fingerprint") {
+            let fingerprint = match mimeparser.lookup_optional_field("Secure-Join-Fingerprint") {
                 Some(fp) => fp,
                 None => {
                     could_not_establish_secure_connection(
@@ -488,7 +485,7 @@ pub fn handle_securejoin_handshake(
             }
             info!(context, "Fingerprint verified.",);
             // verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code
-            let auth_0 = match lookup_field(mimeparser, "Secure-Join-Auth") {
+            let auth_0 = match mimeparser.lookup_optional_field("Secure-Join-Auth") {
                 Some(auth) => auth,
                 None => {
                     could_not_establish_secure_connection(
@@ -517,7 +514,9 @@ pub fn handle_securejoin_handshake(
             emit_event!(context, Event::ContactsChanged(Some(contact_id)));
             inviter_progress!(context, contact_id, 600);
             if join_vg {
-                let field_grpid = lookup_field(mimeparser, "Secure-Join-Group").unwrap_or_default();
+                let field_grpid = mimeparser
+                    .lookup_optional_field("Secure-Join-Group")
+                    .unwrap_or_default();
                 let (group_chat_id, _, _) = chat::get_chat_id_by_grpid(context, &field_grpid);
                 if group_chat_id == 0 {
                     error!(context, "Chat {} not found.", &field_grpid);
@@ -586,8 +585,9 @@ pub fn handle_securejoin_handshake(
             }
             Contact::scaleup_origin_by_id(context, contact_id, Origin::SecurejoinJoined);
             emit_event!(context, Event::ContactsChanged(None));
-            let cg_member_added =
-                lookup_field(mimeparser, "Chat-Group-Member-Added").unwrap_or_default();
+            let cg_member_added = mimeparser
+                .lookup_optional_field("Chat-Group-Member-Added")
+                .unwrap_or_default();
             if join_vg && !addr_equals_self(context, cg_member_added) {
                 info!(context, "Message belongs to a different handshake (scaled up contact anyway to allow creation of group).");
                 return ret;
@@ -651,24 +651,6 @@ fn secure_connection_established(context: &Context, contact_chat_id: u32) {
     emit_event!(context, Event::ChatModified(contact_chat_id));
 }
 
-fn lookup_field(mimeparser: &dc_mimeparser_t, key: &str) -> Option<String> {
-    let field: *mut mailimf_field = dc_mimeparser_lookup_field(mimeparser, key);
-    unsafe {
-        let mut value: *const libc::c_char = ptr::null();
-        if field.is_null()
-            || (*field).fld_type != MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int
-            || (*field).fld_data.fld_optional_field.is_null()
-            || {
-                value = (*(*field).fld_data.fld_optional_field).fld_value;
-                value.is_null()
-            }
-        {
-            return None;
-        }
-        Some(as_str(value).to_string())
-    }
-}
-
 fn could_not_establish_secure_connection(context: &Context, contact_chat_id: u32, details: &str) {
     let contact_id = chat_id_2_contact_id(context, contact_chat_id);
     let contact = Contact::get_by_id(context, contact_id);
@@ -706,10 +688,7 @@ fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Res
  * Tools: Misc.
  ******************************************************************************/
 
-fn encrypted_and_signed(
-    mimeparser: &dc_mimeparser_t,
-    expected_fingerprint: impl AsRef<str>,
-) -> bool {
+fn encrypted_and_signed(mimeparser: &MimeParser, expected_fingerprint: impl AsRef<str>) -> bool {
     if !mimeparser.e2ee_helper.encrypted {
         warn!(mimeparser.context, "Message not encrypted.",);
         false

src/smtp.rs

@@ -82,7 +82,7 @@ impl Smtp {
             // oauth2
             let addr = &lp.addr;
             let send_pw = &lp.send_pw;
-            let access_token = dc_get_oauth2_access_token(context, addr, send_pw, 0);
+            let access_token = dc_get_oauth2_access_token(context, addr, send_pw, false);
             if access_token.is_none() {
                 return false;
             }

src/x.rs

@@ -33,13 +33,6 @@ pub fn strndup(s: *const libc::c_char, n: libc::c_ulong) -> *mut libc::c_char {
     }
 }
 
-extern "C" {
-    pub fn clock() -> libc::clock_t;
-
-    // -- DC Methods
-    pub fn dc_mprintf(format: *const libc::c_char, _: ...) -> *mut libc::c_char;
-}
-
 pub(crate) unsafe fn strcasecmp(s1: *const libc::c_char, s2: *const libc::c_char) -> libc::c_int {
     let s1 = std::ffi::CStr::from_ptr(s1)
         .to_string_lossy()

test-data/key/public.asc

@@ -0,0 +1 @@
+xsBNBF086ewBCACmJKuoxIO6T87yi4Q3MyNpMch3Y8KrtHDQyUszU36eqM3Pmd1lFrbcCd8ZWo2pq6OJSwsM/jjRGn1zo2YOaQeJRRrC+KrKGqSUtRSYQBPrPjE2YjSXAMbu8jBI6VVUhHeghriBkK79PY9O/oRhIJC0p14IJe6CQ6OI2fTmTUHF9i/nJ3G4Wb3/K1bU3yVfyPZjTZQPYPvvh03vxHULKurtYkX5DTEMSWsF4qzLMps+l87VuLV9iQnbN7YMRLHHx2KkX5Ivi7JCefhCa54M0K3bDCCxuVWAM5wjQwNZjzR+WL+dYchwoFvuF8NrlzjM9dSv+2rn+J7f99ijSXarzPC7ABEBAAHNEzxhbGljZUBleGFtcGxlLmNvbT7CwIkEEAEIADMCGQEFAl086fgCGwMECwkIBwYVCAkKCwIDFgIBFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcei3ogf/cruUmQ+th52TFHTHdkw9OHUl3MrXtZ7QmHyOAFvbXE/6n5Eeh+eZoF8MWWV72m14Wbs+vTcNQkFVTdOPptkKA8e4cJqwDOHsyAnvQXZ7WNje9+BMzcoipIUawHP4ORFaPDsKLZQ0b4wBbKn8ziea6zjGF0/qljTdoxTtsYpv5wXYuhwbYklrLOqgSa5M7LXUe7E3g9mbg+9iX1GuB8m6GkquJN814Y+xny4xhZzGOfue6SeP12jJMNSjSP7416dRq7794VGnkkW9V/7oFEUKu5wO9FFbgDySOSlEjByGejSGuBmho0iJSjcPjZ7EY/j3M3orq4dpza5C82OeSvxDFc7ATQRdPOnsAQgA5oLxXRLnyugzOmNCy7dxV3JrDZscA6JNlJlDWIShT0YSs+zG9JzDeQql+sYXgUSxOoIayItuXtnFn7tstwGoOnYvadm/e5/7V5fKAQRtCtdN51av62n18Venlm0yNKpROPcZ6M/sc4m6uU6YRZ/a1idal8VGY0wLKlghjIBuIiBoVQ/RnoW+/fhmwIg08dQ5m8hQe3GEOZEeLrTWL/9awPlXK7Y+DmJOoR4qbHWEcRfbzS6q4zW8vk2ztB8ngwbnqYy8zrN1DCICN1gYdlU++uVw6Bb1XfY8Cdldh1VLKpF35mAmjxLZfVDcoObFH3Cv2GB7BEYxv86KC2Y6T74Q/wARAQABwsB2BBgBCAAgBQJdPOn4AhsMFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcegLxwf/dXshJnoWqEnRsf6rVb9/Mc66ti+NVQLfNd275dybh/QIJdK3NmSxdnTPIEJRVspJywJoupwXFNrnHG2Ff6QPvHqI+/oNu986r9d7Z1oQibbLHKt8t6kpOfg/xGxotagJuiCQvR9mMjD1DqsdB37SjDxGupZOOJSXWi6KX60IE+uM+QOBfeOZziQwuFmA5wV6RDXIeYJfqrcbeXeR1d0nfNpPHQR1gBiqmxNb6KBbdXD2+EXW60axC7D2b1APmzMlammDliPwsK9U1rc9nuquEBvGDOJf4K+Dzn+mDCqRpP6uAuQ7RKHyim4uyN0wwKObzPqgJCGwjTglkixw+aSTXw==

test-data/message/issue_523.txt

@@ -0,0 +1,21 @@
+Return-Path: <x@testrun.org>
+Received: from hq5.merlinux.eu
+	by hq5.merlinux.eu (Dovecot) with LMTP id yRKOBakcfV1AewAAPzvFDg
+	; Sat, 14 Sep 2019 19:00:25 +0200
+Received: from localhost (unknown 7.165.105.24])
+	by hq5.merlinux.eu (Postfix) with ESMTPSA id 8D9844E023;
+	Sat, 14 Sep 2019 19:00:22 +0200 (CEST)
+DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=testrun.org;
+	s=testrun; t=1568480425;
+	bh=GrziQ9bkbioILHZ1tEn81B53bDgaZK+ENbW4MUBiMUM=;
+	h=Date:From:To:In-Reply-To:References:Subject:From;
+	b=eHP/GdBQD1cq601Gaqpz7fd+nQvBJLH7c+bk9KGGC3BKZrRAzehEDOaFlGP2+9oFq
+	 cl+y11nGowenVAw7M5ljjxCpOVy0Aa+atn3e7iZeufgOJPr5Hggg2nPe4qfyP6OmOJ
+	 i9RazyXN1rp4fY7ku9x29g818UL8aWiloJHJ9wqDhMe8OXtIAhJA0gpHDCT1SLgo/a
+	 Kv7/Yj4CA8XS/mRxkbBmpWgcF7SluNjuXU9Npo3aTfjQQ5xSzn72Jsai4n0ppLcQ5k
+	 KobttFy+gkmfQRAe8v7vx51qn82BSsGRlxZWevOB9zit/uk7zb8ZbBqPMeCoWsihRM
+	 LdSqwIpokmYmQ==
+Date: Sat, 14 Sep 2019 19:00:13 +0200
+From: lmn <x@tux.org>
+To: abc <abc@bcd.com>, def <def@def.de>, 
+ jik

tests/stress.rs

@@ -1,6 +1,7 @@
 //! Stress some functions for testing; if used as a lib, this file is obsolete.
 
 use std::collections::HashSet;
+use std::path::PathBuf;
 use std::ptr;
 
 use tempfile::{tempdir, TempDir};
@@ -39,15 +40,10 @@ unsafe fn stress_functions(context: &Context) {
         dc_delete_file(context, "$BLOBDIR/foobar.dadada");
         dc_delete_file(context, "$BLOBDIR/foobar-folder");
     }
-    dc_write_file(
-        context,
-        b"$BLOBDIR/foobar\x00" as *const u8 as *const libc::c_char,
-        b"content\x00" as *const u8 as *const libc::c_char as *const libc::c_void,
-        7,
-    );
+    assert!(dc_write_file(context, "$BLOBDIR/foobar", b"content"));
     assert!(dc_file_exist(context, "$BLOBDIR/foobar",));
     assert!(!dc_file_exist(context, "$BLOBDIR/foobarx"));
-    assert_eq!(dc_get_filebytes(context, "$BLOBDIR/foobar",), 7);
+    assert_eq!(dc_get_filebytes(context, "$BLOBDIR/foobar"), 7);
 
     let abs_path = context
         .get_blobdir()
@@ -87,41 +83,14 @@ unsafe fn stress_functions(context: &Context) {
     assert!(dc_create_folder(context, "$BLOBDIR/foobar-folder"));
     assert!(dc_file_exist(context, "$BLOBDIR/foobar-folder",));
     assert!(!dc_delete_file(context, "$BLOBDIR/foobar-folder"));
-    let fn0: *mut libc::c_char = dc_get_fine_pathNfilename(
-        context,
-        b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
-        b"foobar.dadada\x00" as *const u8 as *const libc::c_char,
-    );
-    assert!(!fn0.is_null());
-    assert_eq!(
-        strcmp(
-            fn0,
-            b"$BLOBDIR/foobar.dadada\x00" as *const u8 as *const libc::c_char,
-        ),
-        0
-    );
-    dc_write_file(
-        context,
-        fn0,
-        b"content\x00" as *const u8 as *const libc::c_char as *const libc::c_void,
-        7,
-    );
-    let fn1: *mut libc::c_char = dc_get_fine_pathNfilename(
-        context,
-        b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
-        b"foobar.dadada\x00" as *const u8 as *const libc::c_char,
-    );
-    assert!(!fn1.is_null());
-    assert_eq!(
-        strcmp(
-            fn1,
-            b"$BLOBDIR/foobar-1.dadada\x00" as *const u8 as *const libc::c_char,
-        ),
-        0
-    );
-    assert!(dc_delete_file(context, as_path(fn0)));
-    free(fn0 as *mut libc::c_void);
-    free(fn1 as *mut libc::c_void);
+    let fn0 = dc_get_fine_path_filename(context, "$BLOBDIR", "foobar.dadada");
+    assert_eq!(fn0, PathBuf::from("$BLOBDIR/foobar.dadada"));
+
+    assert!(dc_write_file(context, &fn0, b"content"));
+    let fn1 = dc_get_fine_path_filename(context, "$BLOBDIR", "foobar.dadada");
+    assert_eq!(fn1, PathBuf::from("$BLOBDIR/foobar-1.dadada"));
+
+    assert!(dc_delete_file(context, &fn0));
 
     let res = context.get_config(config::Config::SysConfigKeys).unwrap();
 
@@ -604,7 +573,7 @@ fn test_dc_get_oauth2_token() {
     let ctx = create_test_context();
     let addr = "dignifiedquire@gmail.com";
     let code = "fail";
-    let res = dc_get_oauth2_access_token(&ctx.ctx, addr, code, 0);
+    let res = dc_get_oauth2_access_token(&ctx.ctx, addr, code, false);
     // this should fail as it is an invalid password
     assert_eq!(res, None);
 }