push down unsafe from whole-function to expressions

remove scanning for old Chat-Predecessor header

deltachat-ffi/deltachat.h

@@ -3719,6 +3719,14 @@ int64_t          dc_lot_get_timestamp     (const dc_lot_t* lot);
 #define DC_MSG_GIF       21
 
 
+/**
+ * Message containing a sticker, similar to image.
+ * If possible, the ui should display the image without borders in a transparent way.
+ * A click on a sticker will offer to install the sticker set in some future.
+ */
+#define DC_MSG_STICKER     23
+
+
 /**
  * Message containing an Audio file.
  * File and duration are set via dc_msg_set_file(), dc_msg_set_duration()
@@ -3896,6 +3904,45 @@ int64_t          dc_lot_get_timestamp     (const dc_lot_t* lot);
  */
 #define DC_EVENT_SMTP_MESSAGE_SENT        103
 
+/**
+ * Emitted when a message was successfully marked as deleted on the IMAP server.
+ *
+ * @param data1 0
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be free()'d or modified and is valid only until the callback returns.
+ * @return 0
+ */
+#define DC_EVENT_IMAP_MESSAGE_DELETED   104
+
+/**
+ * Emitted when a message was successfully moved on IMAP.
+ *
+ * @param data1 0
+ * @param data2 (const char*) Info string in english language.
+ *     Must not be free()'d or modified and is valid only until the callback returns.
+ * @return 0
+ */
+#define DC_EVENT_IMAP_MESSAGE_MOVED   105
+
+/**
+ * Emitted when a new blob file was successfully written 
+ *
+ * @param data1 0
+ * @param data2 (const char*) path name 
+ *     Must not be free()'d or modified and is valid only until the callback returns.
+ * @return 0
+ */
+#define DC_EVENT_NEW_BLOB_FILE 150
+
+/**
+ * Emitted when a blob file was successfully deleted 
+ *
+ * @param data1 0
+ * @param data2 (const char*) path name 
+ *     Must not be free()'d or modified and is valid only until the callback returns.
+ * @return 0
+ */
+#define DC_EVENT_DELETED_BLOB_FILE 151
 
 /**
  * The library-user should write a warning string to the log.

deltachat-ffi/src/lib.rs

@@ -24,9 +24,7 @@ use num_traits::{FromPrimitive, ToPrimitive};
 
 use deltachat::contact::Contact;
 use deltachat::context::Context;
-use deltachat::dc_tools::{
-    as_path, as_str, dc_strdup, to_string, to_string_lossy, OsStrExt, StrExt,
-};
+use deltachat::dc_tools::{as_path, as_str, dc_strdup, to_string_lossy, OsStrExt, StrExt};
 use deltachat::*;
 
 // as C lacks a good and portable error handling,
@@ -125,11 +123,15 @@ impl ContextWrapper {
                     | Event::SmtpConnected(msg)
                     | Event::ImapConnected(msg)
                     | Event::SmtpMessageSent(msg)
+                    | Event::ImapMessageDeleted(msg)
+                    | Event::ImapMessageMoved(msg)
+                    | Event::NewBlobFile(msg)
+                    | Event::DeletedBlobFile(msg)
                     | Event::Warning(msg)
                     | Event::Error(msg)
                     | Event::ErrorNetwork(msg)
                     | Event::ErrorSelfNotInGroup(msg) => {
-                        let data2 = CString::new(msg).unwrap();
+                        let data2 = CString::new(msg).unwrap_or_default();
                         ffi_cb(self, event_id, 0, data2.as_ptr() as uintptr_t)
                     }
                     Event::MsgsChanged { chat_id, msg_id }
@@ -148,7 +150,7 @@ impl ContextWrapper {
                         ffi_cb(self, event_id, progress as uintptr_t, 0)
                     }
                     Event::ImexFileWritten(file) => {
-                        let data1 = file.to_c_string().unwrap();
+                        let data1 = file.to_c_string().unwrap_or_default();
                         ffi_cb(self, event_id, data1.as_ptr() as uintptr_t, 0)
                     }
                     Event::SecurejoinInviterProgress {
@@ -377,8 +379,8 @@ pub unsafe extern "C" fn dc_get_oauth2_url(
         return ptr::null_mut(); // NULL explicitly defined as "unknown"
     }
     let ffi_context = &*context;
-    let addr = to_string(addr);
-    let redirect = to_string(redirect);
+    let addr = to_string_lossy(addr);
+    let redirect = to_string_lossy(redirect);
     ffi_context
         .with_inner(|ctx| match oauth2::dc_get_oauth2_url(ctx, addr, redirect) {
             Some(res) => res.strdup(),
@@ -1245,8 +1247,11 @@ pub unsafe extern "C" fn dc_forward_msgs(
 
     let ffi_context = &*context;
     ffi_context
-        .with_inner(|ctx| chat::forward_msgs(ctx, ids, chat_id))
-        .unwrap_or(())
+        .with_inner(|ctx| {
+            chat::forward_msgs(ctx, ids, chat_id)
+                .unwrap_or_log_default(ctx, "Failed to forward message")
+        })
+        .unwrap_or_default()
 }
 
 #[no_mangle]
@@ -1615,9 +1620,7 @@ pub unsafe extern "C" fn dc_stop_ongoing_process(context: *mut dc_context_t) {
         return;
     }
     let ffi_context = &*context;
-    ffi_context
-        .with_inner(|ctx| configure::dc_stop_ongoing_process(ctx))
-        .ok();
+    ffi_context.with_inner(|ctx| ctx.stop_ongoing()).ok();
 }
 
 #[no_mangle]
@@ -2131,7 +2134,7 @@ pub unsafe extern "C" fn dc_chat_get_profile_image(chat: *mut dc_chat_t) -> *mut
     let ffi_context = &*ffi_chat.context;
     ffi_context
         .with_inner(|ctx| match ffi_chat.chat.get_profile_image(ctx) {
-            Some(p) => p.to_str().unwrap().to_string().strdup(),
+            Some(p) => p.to_string_lossy().strdup(),
             None => ptr::null_mut(),
         })
         .unwrap_or_else(|_| ptr::null_mut())
@@ -2476,7 +2479,7 @@ pub unsafe extern "C" fn dc_msg_get_summarytext(
         .with_inner(|ctx| {
             ffi_msg
                 .message
-                .get_summarytext(ctx, approx_characters.try_into().unwrap())
+                .get_summarytext(ctx, approx_characters.try_into().unwrap_or_default())
         })
         .unwrap_or_default()
         .strdup()
@@ -2768,7 +2771,7 @@ pub unsafe extern "C" fn dc_contact_get_profile_image(
             ffi_contact
                 .contact
                 .get_profile_image(ctx)
-                .map(|p| p.to_str().unwrap().to_string().strdup())
+                .map(|p| p.to_string_lossy().strdup())
                 .unwrap_or_else(|| std::ptr::null_mut())
         })
         .unwrap_or_else(|_| ptr::null_mut())

examples/repl/cmdline.rs

@@ -4,7 +4,6 @@ use std::str::FromStr;
 use deltachat::chat::{self, Chat};
 use deltachat::chatlist::*;
 use deltachat::config;
-use deltachat::configure::*;
 use deltachat::constants::*;
 use deltachat::contact::*;
 use deltachat::context::*;
@@ -119,13 +118,13 @@ fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int {
 
     /* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */
     if !spec.is_null() {
-        real_spec = to_string(spec);
+        real_spec = to_string_lossy(spec);
         context
             .sql
-            .set_config(context, "import_spec", Some(&real_spec))
+            .set_raw_config(context, "import_spec", Some(&real_spec))
             .unwrap();
     } else {
-        let rs = context.sql.get_config(context, "import_spec");
+        let rs = context.sql.get_raw_config(context, "import_spec");
         if rs.is_none() {
             error!(context, "Import: No file or folder given.");
             return 0;
@@ -471,7 +470,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             ensure!(0 != dc_reset_tables(context, bits), "Reset failed");
         }
         "stop" => {
-            dc_stop_ongoing_process(context);
+            context.stop_ongoing();
         }
         "set" => {
             ensure!(!arg1.is_empty(), "Argument <key> missing.");
@@ -864,7 +863,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             let mut msg_ids = [0; 1];
             let chat_id = arg2.parse()?;
             msg_ids[0] = arg1.parse()?;
-            chat::forward_msgs(context, &msg_ids, chat_id);
+            chat::forward_msgs(context, &msg_ids, chat_id)?;
         }
         "markseen" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");

mmime/src/charconv.rs

@@ -17,12 +17,12 @@ pub unsafe fn charconv(
     assert!(!fromcode.is_null(), "invalid fromcode");
     assert!(!s.is_null(), "invalid input string");
     if let Some(encoding) =
-        charset::Charset::for_label(CStr::from_ptr(fromcode).to_str().unwrap().as_bytes())
+        charset::Charset::for_label(CStr::from_ptr(fromcode).to_string_lossy().as_bytes())
     {
         let data = std::slice::from_raw_parts(s as *const u8, strlen(s));
 
         let (res, _, _) = encoding.decode(data);
-        let res_c = CString::new(res.as_bytes()).unwrap();
+        let res_c = CString::new(res.as_bytes()).unwrap_or_default();
         *result = strdup(res_c.as_ptr()) as *mut _;
 
         MAIL_CHARCONV_NO_ERROR as libc::c_int

mmime/src/display.rs

@@ -123,7 +123,7 @@ unsafe fn display_mime_discrete_type(mut discrete_type: *mut mailmime_discrete_t
         _ => {}
     };
 }
-unsafe fn display_mime_data(mut data: *mut mailmime_data) {
+pub unsafe fn display_mime_data(mut data: *mut mailmime_data) {
     match (*data).dt_type {
         0 => {
             println!(

mmime/src/mailimf/write_generic.rs

@@ -1598,7 +1598,7 @@ unsafe fn mailimf_date_time_write_driver(
         (*date_time).dt_sec,
         (*date_time).dt_zone,
     );
-    let date_str_c = std::ffi::CString::new(date_str).unwrap();
+    let date_str_c = std::ffi::CString::new(date_str).unwrap_or_default();
     let r = mailimf_string_write_driver(
         do_write,
         data,

mmime/src/mailmime/types_helper.rs

@@ -848,7 +848,7 @@ pub unsafe fn mailmime_generate_boundary() -> *mut libc::c_char {
         hex::encode(&std::process::id().to_le_bytes()[..2])
     );
 
-    let c = std::ffi::CString::new(raw).unwrap();
+    let c = std::ffi::CString::new(raw).unwrap_or_default();
     strdup(c.as_ptr())
 }
 

mmime/src/mailmime/write_generic.rs

@@ -338,7 +338,7 @@ unsafe fn mailmime_disposition_param_write_driver(
         4 => {
             let value = (*param).pa_data.pa_size as u32;
             let raw = format!("{}", value);
-            let raw_c = std::ffi::CString::new(raw).unwrap();
+            let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
             sizestr = strdup(raw_c.as_ptr());
             len = strlen(b"size=\x00" as *const u8 as *const libc::c_char)
                 .wrapping_add(strlen(sizestr))
@@ -542,7 +542,7 @@ unsafe fn mailmime_version_write_driver(
     }
 
     let raw = format!("{}.{}", (version >> 16) as i32, (version & 0xffff) as i32);
-    let raw_c = std::ffi::CString::new(raw).unwrap();
+    let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
     let mut versionstr = strdup(raw_c.as_ptr());
     r = mailimf_string_write_driver(do_write, data, col, versionstr, strlen(versionstr));
     if r != MAILIMF_NO_ERROR as libc::c_int {
@@ -1515,8 +1515,8 @@ pub unsafe fn mailmime_data_write_driver(
         }
         1 => {
             let filename = CStr::from_ptr((*mime_data).dt_data.dt_filename)
-                .to_str()
-                .unwrap();
+                .to_string_lossy()
+                .into_owned();
             if let Ok(file) = std::fs::File::open(filename) {
                 if let Ok(mut text) = memmap::MmapOptions::new().map_copy(&file) {
                     if 0 != (*mime_data).dt_encoded {
@@ -1797,7 +1797,7 @@ pub unsafe fn mailmime_quoted_printable_write_driver(
                             start = text.offset(i as isize).offset(1isize);
 
                             let raw = format!("={:02X}", (ch as libc::c_int));
-                            let raw_c = std::ffi::CString::new(raw).unwrap();
+                            let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
                             let mut hexstr = strdup(raw_c.as_ptr());
                             r = mailimf_string_write_driver(
                                 do_write,
@@ -1822,7 +1822,7 @@ pub unsafe fn mailmime_quoted_printable_write_driver(
                         }
                         start = text.offset(i as isize).offset(1isize);
                         let raw = format!("={:02X}", ch as libc::c_int);
-                        let raw_c = std::ffi::CString::new(raw).unwrap();
+                        let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
                         let mut hexstr = strdup(raw_c.as_ptr());
                         r = mailimf_string_write_driver(
                             do_write,
@@ -1866,7 +1866,7 @@ pub unsafe fn mailmime_quoted_printable_write_driver(
                     }
                     start = text.offset(i as isize);
                     let raw = format!("={:02X}", b'\r' as i32);
-                    let raw_c = std::ffi::CString::new(raw).unwrap();
+                    let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
                     let mut hexstr = strdup(raw_c.as_ptr());
                     r = mailimf_string_write_driver(do_write, data, col, hexstr, 3i32 as size_t);
                     if r != MAILIMF_NO_ERROR as libc::c_int {
@@ -1890,7 +1890,7 @@ pub unsafe fn mailmime_quoted_printable_write_driver(
                         "={:02X}\r\n",
                         *text.offset(i.wrapping_sub(1i32 as libc::size_t) as isize) as libc::c_int
                     );
-                    let raw_c = std::ffi::CString::new(raw).unwrap();
+                    let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
                     let mut hexstr = strdup(raw_c.as_ptr());
 
                     r = mailimf_string_write_driver(do_write, data, col, hexstr, strlen(hexstr));
@@ -1917,7 +1917,7 @@ pub unsafe fn mailmime_quoted_printable_write_driver(
                         "={:02X}\r\n",
                         *text.offset(i.wrapping_sub(2i32 as libc::size_t) as isize) as libc::c_int
                     );
-                    let raw_c = std::ffi::CString::new(raw).unwrap();
+                    let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
                     let mut hexstr = strdup(raw_c.as_ptr());
 
                     r = mailimf_string_write_driver(do_write, data, col, hexstr, strlen(hexstr));
@@ -1938,7 +1938,7 @@ pub unsafe fn mailmime_quoted_printable_write_driver(
                         (*text.offset(i.wrapping_sub(2i32 as libc::size_t) as isize) as u8 as char),
                         b'\r' as i32
                     );
-                    let raw_c = std::ffi::CString::new(raw).unwrap();
+                    let raw_c = std::ffi::CString::new(raw).unwrap_or_default();
                     let mut hexstr = strdup(raw_c.as_ptr());
 
                     r = mailimf_string_write_driver(do_write, data, col, hexstr, strlen(hexstr));

python/README.rst

@@ -97,7 +97,7 @@ If you want to run "liveconfig" functional tests you can set
   chat devs.
 
 - or the path of a file that contains two lines, each describing
-  via "addr=... mail_pwd=..." a test account login that will
+  via "addr=... mail_pw=..." a test account login that will
   be used for the live tests.
 
 With ``DCC_PY_LIVECONFIG`` set pytest invocations will use real

python/src/deltachat/account.py

@@ -1,6 +1,7 @@
 """ Account class implementation. """
 
 from __future__ import print_function
+import atexit
 import threading
 import re
 import time
@@ -49,9 +50,10 @@ class Account(object):
             raise ValueError("Could not dc_open: {}".format(db_path))
         self._configkeys = self.get_config("sys.config_keys").split()
         self._imex_events = Queue()
+        atexit.register(self.shutdown)
 
-    def __del__(self):
-        self.shutdown()
+    # def __del__(self):
+    #    self.shutdown()
 
     def _check_config_key(self, name):
         if name not in self._configkeys:
@@ -411,6 +413,9 @@ class Account(object):
             raise ValueError("could not join group")
         return Chat(self, chat_id)
 
+    def stop_ongoing(self):
+        lib.dc_stop_ongoing_process(self._dc_context)
+
     #
     # meta API for start/stop and event based processing
     #
@@ -432,7 +437,7 @@ class Account(object):
 
     def stop_threads(self, wait=True):
         """ stop IMAP/SMTP threads. """
-        lib.dc_stop_ongoing_process(self._dc_context)
+        self.stop_ongoing()
         self._threads.stop(wait=wait)
 
     def shutdown(self, wait=True):
@@ -444,6 +449,7 @@ class Account(object):
             self.stop_threads(wait=wait)  # to wait for threads
             deltachat.clear_context_callback(self._dc_context)
             del self._dc_context
+            atexit.unregister(self.shutdown)
 
     def _process_event(self, ctx, evt_name, data1, data2):
         assert ctx == self._dc_context
@@ -574,11 +580,11 @@ class EventLogger:
             else:
                 assert not rex.match(ev[0]), "event found {}".format(ev)
 
-    def get_matching(self, event_name_regex, check_error=True):
+    def get_matching(self, event_name_regex, check_error=True, timeout=None):
         self._log("-- waiting for event with regex: {} --".format(event_name_regex))
         rex = re.compile("(?:{}).*".format(event_name_regex))
         while 1:
-            ev = self.get()
+            ev = self.get(timeout=timeout, check_error=check_error)
             if rex.match(ev[0]):
                 return ev
 

python/src/deltachat/const.py

@@ -8,9 +8,6 @@ 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
@@ -55,6 +52,7 @@ DC_CONTACT_ID_LAST_SPECIAL = 9
 DC_MSG_TEXT = 10
 DC_MSG_IMAGE = 20
 DC_MSG_GIF = 21
+DC_MSG_STICKER = 23
 DC_MSG_AUDIO = 40
 DC_MSG_VOICE = 41
 DC_MSG_VIDEO = 50
@@ -63,6 +61,10 @@ DC_EVENT_INFO = 100
 DC_EVENT_SMTP_CONNECTED = 101
 DC_EVENT_IMAP_CONNECTED = 102
 DC_EVENT_SMTP_MESSAGE_SENT = 103
+DC_EVENT_IMAP_MESSAGE_DELETED = 104
+DC_EVENT_IMAP_MESSAGE_MOVED = 105
+DC_EVENT_NEW_BLOB_FILE = 150
+DC_EVENT_DELETED_BLOB_FILE = 151
 DC_EVENT_WARNING = 300
 DC_EVENT_ERROR = 400
 DC_EVENT_ERROR_NETWORK = 401
@@ -83,6 +85,9 @@ DC_EVENT_SECUREJOIN_JOINER_PROGRESS = 2061
 DC_EVENT_GET_STRING = 2091
 DC_EVENT_FILE_COPIED = 2055
 DC_EVENT_IS_OFFLINE = 2081
+DC_PROVIDER_STATUS_OK = 1
+DC_PROVIDER_STATUS_PREPARATION = 2
+DC_PROVIDER_STATUS_BROKEN = 3
 # end const generated
 
 

python/tests/conftest.py

@@ -157,6 +157,11 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig):
             self.live_count += 1
             if "e2ee_enabled" not in configdict:
                 configdict["e2ee_enabled"] = "1"
+
+            # Enable strict certificate checks for online accounts
+            configdict["imap_certificate_checks"] = "1"
+            configdict["smtp_certificate_checks"] = "1"
+
             tmpdb = tmpdir.join("livedb%d" % self.live_count)
             ac = self.make_account(tmpdb.strpath, logid="ac{}".format(self.live_count))
             ac._evlogger.init_time = self.init_time

python/tests/test_account.py

@@ -1,6 +1,7 @@
 from __future__ import print_function
 import pytest
 import os
+import queue
 from deltachat import const, Account
 from deltachat.message import Message
 from datetime import datetime, timedelta
@@ -19,6 +20,7 @@ class TestOfflineAccountBasic:
         d = ac1.get_info()
         assert d["arch"]
         assert d["number_of_chats"] == "0"
+        assert d["bcc_self"] == "1"
 
     def test_is_not_configured(self, acfactory):
         ac1 = acfactory.get_unconfigured_account()
@@ -37,6 +39,11 @@ class TestOfflineAccountBasic:
         ac1 = acfactory.get_unconfigured_account()
         assert "save_mime_headers" in ac1.get_config("sys.config_keys").split()
 
+    def test_has_bccself(self, acfactory):
+        ac1 = acfactory.get_unconfigured_account()
+        assert "bcc_self" in ac1.get_config("sys.config_keys").split()
+        assert ac1.get_config("bcc_self") == "1"
+
     def test_selfcontact_if_unconfigured(self, acfactory):
         ac1 = acfactory.get_unconfigured_account()
         with pytest.raises(ValueError):
@@ -93,7 +100,7 @@ class TestOfflineContact:
         ac1 = acfactory.get_configured_offline_account()
         contact1 = ac1.create_contact(email="some1@example.com", name="some1")
         chat = ac1.create_chat_by_contact(contact1)
-        msg = chat.send_text("one messae")
+        msg = chat.send_text("one message")
         assert not ac1.delete_contact(contact1)
         assert not msg.filemime
 
@@ -222,7 +229,9 @@ class TestOfflineChat:
             chat1.send_image(path="notexists")
         fn = data.get_path("d.png")
         lp.sec("sending image")
+        chat1.account._evlogger.consume_events()
         msg = chat1.send_image(fn)
+        chat1.account._evlogger.get_matching("DC_EVENT_NEW_BLOB_FILE")
         assert msg.is_image()
         assert msg
         assert msg.id > 0
@@ -341,6 +350,12 @@ class TestOnlineAccount:
         assert chat.id > const.DC_CHAT_ID_LAST_SPECIAL
         return chat
 
+    def test_configure_canceled(self, acfactory):
+        ac1 = acfactory.get_online_configuring_account()
+        wait_configuration_progress(ac1, 200)
+        ac1.stop_ongoing()
+        wait_configuration_progress(ac1, 0, 0)
+
     def test_export_import_self_keys(self, acfactory, tmpdir):
         ac1, ac2 = acfactory.get_two_online_accounts()
         dir = tmpdir.mkdir("exportdir")
@@ -351,18 +366,34 @@ class TestOnlineAccount:
         ac1._evlogger.consume_events()
         ac1.import_self_keys(dir.strpath)
 
-    def test_one_account_send(self, acfactory):
+    def test_one_account_send_bcc_setting(self, acfactory, lp):
         ac1 = acfactory.get_online_configuring_account()
-        c2 = ac1.create_contact(email=ac1.get_config("addr"))
+        c2 = ac1.create_contact(email="notexists@testrun.org")
         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)
 
+        lp.sec("send out message with bcc to ourselves")
         msg_out = chat.send_text("message2")
-        # wait for own account to receive
-        ev = ac1._evlogger.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
-        assert ev[1] == msg_out.id
+        ev = ac1._evlogger.get_matching("DC_EVENT_MSGS_CHANGED")
+        assert ev[2] == msg_out.id
+        # wait for send out (BCC)
+        assert ac1.get_config("bcc_self") == "1"
+        self_addr = ac1.get_config("addr")
+        ev = ac1._evlogger.get_matching("DC_EVENT_SMTP_MESSAGE_SENT")
+        assert self_addr in ev[2]
+        ev = ac1._evlogger.get_matching("DC_EVENT_DELETED_BLOB_FILE")
+
+        ac1._evlogger.consume_events()
+        lp.sec("send out message without bcc")
+        ac1.set_config("bcc_self", "0")
+        msg_out = chat.send_text("message3")
+        ev = ac1._evlogger.get_matching("DC_EVENT_MSGS_CHANGED")
+        assert ev[2] == msg_out.id
+        ev = ac1._evlogger.get_matching("DC_EVENT_SMTP_MESSAGE_SENT")
+        assert self_addr not in ev[2]
+        ev = ac1._evlogger.get_matching("DC_EVENT_DELETED_BLOB_FILE")
 
     def test_mvbox_sentbox_threads(self, acfactory):
         ac1 = acfactory.get_online_configuring_account(mvbox=True, sentbox=True)
@@ -374,6 +405,17 @@ class TestOnlineAccount:
         ev = ac2._evlogger.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
         assert ev[2] > const.DC_CHAT_ID_LAST_SPECIAL
 
+    def test_move_works(self, acfactory):
+        ac1 = acfactory.get_online_configuring_account()
+        ac2 = acfactory.get_online_configuring_account(mvbox=True)
+        wait_configuration_progress(ac2, 1000)
+        wait_configuration_progress(ac1, 1000)
+        chat = self.get_chat(ac1, ac2)
+        chat.send_text("message1")
+        ev = ac2._evlogger.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
+        assert ev[2] > const.DC_CHAT_ID_LAST_SPECIAL
+        ev = ac2._evlogger.get_matching("DC_EVENT_IMAP_MESSAGE_MOVED")
+
     def test_forward_messages(self, acfactory):
         ac1, ac2 = acfactory.get_two_online_accounts()
         chat = self.get_chat(ac1, ac2)
@@ -444,6 +486,14 @@ class TestOnlineAccount:
         lp.step("2")
         assert msg_out.is_out_mdn_received()
 
+        lp.sec("check that a second call to mark_seen does not create change or smtp job")
+        ac2._evlogger.consume_events()
+        ac2.mark_seen_messages([msg_in])
+        try:
+            ac2._evlogger.get_matching("DC_EVENT_MSG_READ", timeout=0.01)
+        except queue.Empty:
+            pass  # mark_seen_messages() has generated events before it returns
+
     def test_send_and_receive_will_encrypt_decrypt(self, acfactory, lp):
         ac1, ac2 = acfactory.get_two_online_accounts()
 
@@ -472,6 +522,14 @@ class TestOnlineAccount:
         assert msg_back.text == "message-back"
         assert msg_back.is_encrypted()
 
+        lp.sec("create group chat with two members, one of which has no encrypt state")
+        chat = ac1.create_group_chat("encryption test")
+        chat.add_contact(ac1.create_contact(ac2.get_config("addr")))
+        chat.add_contact(ac1.create_contact("notexisting@testrun.org"))
+        msg = chat.send_text("test not encrypt")
+        ev = ac1._evlogger.get_matching("DC_EVENT_SMTP_MESSAGE_SENT")
+        assert not msg.is_encrypted()
+
     def test_saved_mime_on_received_message(self, acfactory, lp):
         ac1, ac2 = acfactory.get_two_online_accounts()
 
@@ -576,6 +634,9 @@ class TestOnlineAccount:
         lp.sec("ac2: start QR-code based join-group protocol")
         ch = ac2.qr_join_chat(qr)
         assert ch.id >= 10
+        # check that at least some of the handshake messages are deleted
+        ac1._evlogger.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
+        ac2._evlogger.get_matching("DC_EVENT_IMAP_MESSAGE_DELETED")
         wait_securejoin_inviter_progress(ac1, 1000)
 
     def test_qr_verified_group_and_chatting(self, acfactory, lp):

src/aheader.rs

@@ -79,27 +79,21 @@ impl Aheader {
                 let optional_field = unsafe { (*field).fld_data.fld_optional_field };
                 if !optional_field.is_null()
                     && unsafe { !(*optional_field).fld_name.is_null() }
-                    && unsafe { CStr::from_ptr((*optional_field).fld_name).to_str().unwrap() }
+                    && unsafe { CStr::from_ptr((*optional_field).fld_name).to_string_lossy() }
                         == "Autocrypt"
                 {
-                    let value = unsafe {
-                        CStr::from_ptr((*optional_field).fld_value)
-                            .to_str()
-                            .unwrap()
-                    };
+                    let value =
+                        unsafe { CStr::from_ptr((*optional_field).fld_value).to_string_lossy() };
 
-                    match Self::from_str(value) {
-                        Ok(test) => {
-                            if addr_cmp(&test.addr, wanted_from) {
-                                if fine_header.is_none() {
-                                    fine_header = Some(test);
-                                } else {
-                                    // TODO: figure out what kind of error case this is
-                                    return None;
-                                }
+                    if let Ok(test) = Self::from_str(&value) {
+                        if addr_cmp(&test.addr, wanted_from) {
+                            if fine_header.is_none() {
+                                fine_header = Some(test);
+                            } else {
+                                // TODO: figure out what kind of error case this is
+                                return None;
                             }
                         }
-                        _ => {}
                     }
                 }
             }
@@ -131,9 +125,9 @@ impl str::FromStr for Aheader {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut attributes: BTreeMap<String, String> = s
-            .split(";")
+            .split(';')
             .filter_map(|a| {
-                let attribute: Vec<&str> = a.trim().splitn(2, "=").collect();
+                let attribute: Vec<&str> = a.trim().splitn(2, '=').collect();
                 if attribute.len() < 2 {
                     return None;
                 }
@@ -178,7 +172,7 @@ impl str::FromStr for Aheader {
 
         // Autocrypt-Level0: unknown attributes starting with an underscore can be safely ignored
         // Autocrypt-Level0: unknown attribute, treat the header as invalid
-        if attributes.keys().find(|k| !k.starts_with("_")).is_some() {
+        if attributes.keys().any(|k| !k.starts_with('_')) {
             return Err(());
         }
 

src/chat.rs

@@ -152,21 +152,23 @@ impl Chat {
                 return context.stock_str(StockMessage::DeadDrop).into();
             }
             let cnt = get_chat_contact_cnt(context, self.id);
-            return context
-                .stock_string_repl_int(StockMessage::Member, cnt as i32)
-                .into();
+            return context.stock_string_repl_int(StockMessage::Member, cnt as i32);
         }
 
-        return "Err".into();
+        "Err".to_string()
     }
 
     pub fn get_parent_mime_headers(&self, context: &Context) -> Option<(String, String, String)> {
         let collect = |row: &rusqlite::Row| Ok((row.get(0)?, row.get(1)?, row.get(2)?));
         let params = params![self.id as i32, DC_CONTACT_ID_SELF as i32];
         let sql = &context.sql;
+
+        // use the last messsage of another user in the group as the parent
         let main_query = "SELECT rfc724_mid, mime_in_reply_to, mime_references \
                           FROM msgs WHERE chat_id=?1 AND timestamp=(SELECT max(timestamp) \
                           FROM msgs WHERE chat_id=?1 AND from_id!=?2);";
+
+        // there are no messages of other users - use the first message if SELF as parent
         let fallback_query = "SELECT rfc724_mid, mime_in_reply_to, mime_references \
                               FROM msgs WHERE chat_id=?1 AND timestamp=(SELECT min(timestamp) \
                               FROM msgs WHERE chat_id=?1 AND from_id==?2);";
@@ -289,7 +291,7 @@ impl Chat {
                 if self.typ == Chattype::Group || self.typ == Chattype::VerifiedGroup {
                     if self.param.get_int(Param::Unpromoted).unwrap_or_default() == 1 {
                         self.param.remove(Param::Unpromoted);
-                        self.update_param(context).unwrap();
+                        self.update_param(context)?;
                     }
                 }
             }
@@ -299,16 +301,15 @@ impl Chat {
             so that E2EE is no longer available at a later point (reset, changed settings),
             we do not send the message out at all */
             do_guarantee_e2ee = false;
-            e2ee_enabled = context
-                .sql
-                .get_config_int(context, "e2ee_enabled")
-                .unwrap_or_else(|| 1)
-                == 1;
+            e2ee_enabled = context.get_config_bool(Config::E2eeEnabled);
             if e2ee_enabled && msg.param.get_int(Param::ForcePlaintext).unwrap_or_default() == 0 {
-                let mut can_encrypt = 1;
-                let mut all_mutual = 1;
+                let mut can_encrypt = true;
+                let mut all_mutual = true;
 
-                let res = context.sql.query_row(
+                // take care that this statement returns NULL rows
+                // if there is no peerstates for a chat member!
+                // for DC_PARAM_SELFTALK this statement does not return any row
+                let res = context.sql.query_map(
                     "SELECT ps.prefer_encrypted, c.addr \
                      FROM chats_contacts cc  \
                      LEFT JOIN contacts c ON cc.contact_id=c.id  \
@@ -316,29 +317,32 @@ impl Chat {
                      WHERE cc.chat_id=?  AND cc.contact_id>9;",
                     params![self.id],
                     |row| {
-                        let state: String = row.get(1)?;
+                        let addr: String = row.get(1)?;
 
                         if let Some(prefer_encrypted) = row.get::<_, Option<i32>>(0)? {
+                            // the peerstate exist, so we have either public_key or gossip_key
+                            // and can encrypt potentially
                             if prefer_encrypted != 1 {
                                 info!(
                                     context,
                                     "[autocrypt] peerstate for {} is {}",
-                                    state,
+                                    addr,
                                     if prefer_encrypted == 0 {
                                         "NOPREFERENCE"
                                     } else {
                                         "RESET"
                                     },
                                 );
-                                all_mutual = 0;
+                                all_mutual = false;
                             }
                         } else {
-                            info!(context, "[autocrypt] no peerstate for {}", state,);
-                            can_encrypt = 0;
-                            all_mutual = 0;
+                            info!(context, "[autocrypt] no peerstate for {}", addr,);
+                            can_encrypt = false;
+                            all_mutual = false;
                         }
                         Ok(())
                     },
+                    |rows| rows.collect::<Result<Vec<_>, _>>().map_err(Into::into),
                 );
                 match res {
                     Ok(_) => {}
@@ -347,8 +351,8 @@ impl Chat {
                     }
                 }
 
-                if 0 != can_encrypt {
-                    if 0 != all_mutual {
+                if can_encrypt {
+                    if all_mutual {
                         do_guarantee_e2ee = true;
                     } else if last_msg_in_chat_encrypted(context, &context.sql, self.id) {
                         do_guarantee_e2ee = true;
@@ -358,7 +362,15 @@ impl Chat {
             if do_guarantee_e2ee {
                 msg.param.set_int(Param::GuranteeE2ee, 1);
             }
+            // reset eg. for forwarding
             msg.param.remove(Param::ErroneousE2ee);
+
+            // set "In-Reply-To:" to identify the message to which the composed message is a reply;
+            // set "References:" to identify the "thread" of the conversation;
+            // both according to RFC 5322 3.6.4, page 25
+            //
+            // as self-talks are mainly used to transfer data between devices,
+            // we do not set In-Reply-To/References in this case.
             if !self.is_self_talk() {
                 if let Some((parent_rfc724_mid, parent_in_reply_to, parent_references)) =
                     self.get_parent_mime_headers(context)
@@ -366,6 +378,9 @@ impl Chat {
                     if !parent_rfc724_mid.is_empty() {
                         new_in_reply_to = parent_rfc724_mid.clone();
                     }
+
+                    // the whole list of messages referenced may be huge;
+                    // only use the oldest and and the parent message
                     let parent_references = if let Some(n) = parent_references.find(' ') {
                         &parent_references[0..n]
                     } else {
@@ -373,6 +388,7 @@ impl Chat {
                     };
 
                     if !parent_references.is_empty() && !parent_rfc724_mid.is_empty() {
+                        // angle brackets are added by the mimefactory later
                         new_references = format!("{} {}", parent_references, parent_rfc724_mid);
                     } else if !parent_references.is_empty() {
                         new_references = parent_references.to_string();
@@ -646,6 +662,7 @@ pub fn msgtype_has_file(msgtype: Viewtype) -> bool {
     match msgtype {
         Viewtype::Image => true,
         Viewtype::Gif => true,
+        Viewtype::Sticker => true,
         Viewtype::Audio => true,
         Viewtype::Voice => true,
         Viewtype::Video => true,
@@ -783,10 +800,7 @@ pub fn send_msg(context: &Context, chat_id: u32, msg: &mut Message) -> Result<u3
         message::update_msg_state(context, msg.id, MessageState::OutPending);
     }
 
-    ensure!(
-        job_send_msg(context, msg.id) != 0,
-        "Failed to initiate send job"
-    );
+    job_send_msg(context, msg.id)?;
 
     context.call_cb(Event::MsgsChanged {
         chat_id: msg.chat_id,
@@ -805,11 +819,8 @@ pub fn send_msg(context: &Context, chat_id: u32, msg: &mut Message) -> Result<u3
                 if 0 == id {
                     // avoid hanging if user tampers with db
                     break;
-                } else {
-                    if let Ok(mut copy) = Message::load_from_db(context, id as u32) {
-                        // TODO: handle cleanup and return early instead
-                        send_msg(context, 0, &mut copy).unwrap();
-                    }
+                } else if let Ok(mut copy) = Message::load_from_db(context, id as u32) {
+                    send_msg(context, 0, &mut copy)?;
                 }
             }
             msg.param.remove(Param::PrepForwards);
@@ -962,10 +973,7 @@ pub fn get_chat_msgs(context: &Context, chat_id: u32, flags: u32, marker1before:
     };
 
     let success = if chat_id == 1 {
-        let show_emails = context
-            .sql
-            .get_config_int(context, "show_emails")
-            .unwrap_or_default();
+        let show_emails = context.get_config_int(Config::ShowEmails);
         context.sql.query_map(
             "SELECT m.id, m.timestamp FROM msgs m \
              LEFT JOIN chats ON m.chat_id=chats.id \
@@ -1381,11 +1389,10 @@ pub(crate) fn add_contact_to_chat_ex(
     }
     if from_handshake && chat.param.get_int(Param::Unpromoted).unwrap_or_default() == 1 {
         chat.param.remove(Param::Unpromoted);
-        chat.update_param(context).unwrap();
+        chat.update_param(context)?;
     }
     let self_addr = context
-        .sql
-        .get_config(context, "configured_addr")
+        .get_config(Config::ConfiguredAddr)
         .unwrap_or_default();
     if contact.get_addr() == &self_addr {
         bail!("invalid attempt to add self e-mail address to group");
@@ -1399,14 +1406,14 @@ pub(crate) fn add_contact_to_chat_ex(
         }
     } else {
         // else continue and send status mail
-        if chat.typ == Chattype::VerifiedGroup {
-            if contact.is_verified(context) != VerifiedStatus::BidirectVerified {
-                error!(
-                    context,
-                    "Only bidirectional verified contacts can be added to verified groups."
-                );
-                return Ok(false);
-            }
+        if chat.typ == Chattype::VerifiedGroup
+            && contact.is_verified(context) != VerifiedStatus::BidirectVerified
+        {
+            error!(
+                context,
+                "Only bidirectional verified contacts can be added to verified groups."
+            );
+            return Ok(false);
         }
         if !add_to_chat_contacts_table(context, chat_id, contact_id) {
             return Ok(false);
@@ -1423,14 +1430,14 @@ pub(crate) fn add_contact_to_chat_ex(
         msg.param.set_int(Param::Cmd, 4);
         msg.param.set(Param::Arg, contact.get_addr());
         msg.param.set_int(Param::Arg2, from_handshake.into());
-        msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
+        msg.id = send_msg(context, chat_id, &mut msg)?;
         context.call_cb(Event::MsgsChanged {
             chat_id,
             msg_id: msg.id,
         });
     }
     context.call_cb(Event::MsgsChanged { chat_id, msg_id: 0 });
-    return Ok(true);
+    Ok(true)
 }
 
 fn real_group_exists(context: &Context, chat_id: u32) -> bool {
@@ -1517,7 +1524,7 @@ pub fn remove_contact_from_chat(
                     if chat.is_promoted() {
                         msg.type_0 = Viewtype::Text;
                         if contact.id == DC_CONTACT_ID_SELF {
-                            set_group_explicitly_left(context, chat.grpid).unwrap();
+                            set_group_explicitly_left(context, chat.grpid)?;
                             msg.text = Some(context.stock_system_msg(
                                 StockMessage::MsgGroupLeft,
                                 "",
@@ -1534,7 +1541,7 @@ pub fn remove_contact_from_chat(
                         }
                         msg.param.set_int(Param::Cmd, 5);
                         msg.param.set(Param::Arg, contact.get_addr());
-                        msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
+                        msg.id = send_msg(context, chat_id, &mut msg)?;
                         context.call_cb(Event::MsgsChanged {
                             chat_id,
                             msg_id: msg.id,
@@ -1598,7 +1605,7 @@ pub fn set_chat_name(
     let mut msg = Message::default();
 
     if real_group_exists(context, chat_id) {
-        if &chat.name == new_name.as_ref() {
+        if chat.name == new_name.as_ref() {
             success = true;
         } else if !is_contact_in_chat(context, chat_id, 1) {
             emit_event!(
@@ -1631,7 +1638,7 @@ pub fn set_chat_name(
                     if !chat.name.is_empty() {
                         msg.param.set(Param::Arg, &chat.name);
                     }
-                    msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
+                    msg.id = send_msg(context, chat_id, &mut msg)?;
                     context.call_cb(Event::MsgsChanged {
                         chat_id,
                         msg_id: msg.id,
@@ -1700,7 +1707,7 @@ pub fn set_chat_profile_image(
                     "",
                     DC_CONTACT_ID_SELF,
                 ));
-                msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
+                msg.id = send_msg(context, chat_id, &mut msg)?;
                 emit_event!(
                     context,
                     Event::MsgsChanged {
@@ -1716,36 +1723,35 @@ pub fn set_chat_profile_image(
     bail!("Failed to set profile image");
 }
 
-pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) {
-    if msg_ids.is_empty() || chat_id <= DC_CHAT_ID_LAST_SPECIAL {
-        return;
-    }
+pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) -> Result<(), Error> {
+    ensure!(!msg_ids.is_empty(), "empty msgs_ids: no one to forward to");
+    ensure!(
+        chat_id > DC_CHAT_ID_LAST_SPECIAL,
+        "can not forward to special chat"
+    );
 
     let mut created_db_entries = Vec::new();
     let mut curr_timestamp: i64;
 
-    unarchive(context, chat_id).unwrap();
+    unarchive(context, chat_id)?;
     if let Ok(mut chat) = Chat::load_from_db(context, chat_id) {
         curr_timestamp = dc_create_smeared_timestamps(context, msg_ids.len());
         let idsstr = msg_ids
-            .into_iter()
+            .iter()
             .enumerate()
             .fold(String::with_capacity(2 * msg_ids.len()), |acc, (i, n)| {
                 (if i == 0 { acc } else { acc + "," }) + &n.to_string()
             });
 
-        let ids = context
-            .sql
-            .query_map(
-                format!(
-                    "SELECT id FROM msgs WHERE id IN({}) ORDER BY timestamp,id",
-                    idsstr
-                ),
-                params![],
-                |row| row.get::<_, i32>(0),
-                |ids| ids.collect::<Result<Vec<_>, _>>().map_err(Into::into),
-            )
-            .unwrap(); // TODO: better error handling
+        let ids = context.sql.query_map(
+            format!(
+                "SELECT id FROM msgs WHERE id IN({}) ORDER BY timestamp,id",
+                idsstr
+            ),
+            params![],
+            |row| row.get::<_, i32>(0),
+            |ids| ids.collect::<Result<Vec<_>, _>>().map_err(Into::into),
+        )?;
 
         for id in ids {
             let src_msg_id = id;
@@ -1765,7 +1771,7 @@ pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) {
             let new_msg_id: u32;
             if msg.state == MessageState::OutPreparing {
                 let fresh9 = curr_timestamp;
-                curr_timestamp = curr_timestamp + 1;
+                curr_timestamp += 1;
                 new_msg_id = chat
                     .prepare_msg_raw(context, &mut msg, fresh9)
                     .unwrap_or_default();
@@ -1785,11 +1791,11 @@ pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) {
             } else {
                 msg.state = MessageState::OutPending;
                 let fresh10 = curr_timestamp;
-                curr_timestamp = curr_timestamp + 1;
+                curr_timestamp += 1;
                 new_msg_id = chat
                     .prepare_msg_raw(context, &mut msg, fresh10)
                     .unwrap_or_default();
-                job_send_msg(context, new_msg_id);
+                job_send_msg(context, new_msg_id)?;
             }
             created_db_entries.push(chat_id);
             created_db_entries.push(new_msg_id);
@@ -1802,6 +1808,8 @@ pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) {
             msg_id: created_db_entries[i + 1],
         });
     }
+
+    Ok(())
 }
 
 pub fn get_chat_contact_cnt(context: &Context, chat_id: u32) -> usize {

src/chatlist.rs

@@ -182,7 +182,7 @@ impl Chatlist {
             if 0 == listflags & DC_GCL_NO_SPECIALS {
                 let last_deaddrop_fresh_msg_id = get_last_deaddrop_fresh_msg(context);
                 if last_deaddrop_fresh_msg_id > 0 {
-                    ids.push((1, last_deaddrop_fresh_msg_id));
+                    ids.insert(0, (DC_CHAT_ID_DEADDROP, last_deaddrop_fresh_msg_id));
                 }
                 add_archived_link_item = 1;
             }
@@ -258,13 +258,11 @@ impl Chatlist {
         let chat_loaded: Chat;
         let chat = if let Some(chat) = chat {
             chat
+        } else if let Ok(chat) = Chat::load_from_db(context, self.ids[index].0) {
+            chat_loaded = chat;
+            &chat_loaded
         } else {
-            if let Ok(chat) = Chat::load_from_db(context, self.ids[index].0) {
-                chat_loaded = chat;
-                &chat_loaded
-            } else {
-                return ret;
-            }
+            return ret;
         };
 
         let lastmsg_id = self.ids[index].1;

src/config.rs

@@ -19,10 +19,12 @@ pub enum Config {
     MailUser,
     MailPw,
     MailPort,
+    ImapCertificateChecks,
     SendServer,
     SendUser,
     SendPw,
     SendPort,
+    SmtpCertificateChecks,
     ServerFlags,
     #[strum(props(default = "INBOX"))]
     ImapFolder,
@@ -30,6 +32,8 @@ pub enum Config {
     Selfstatus,
     Selfavatar,
     #[strum(props(default = "1"))]
+    BccSelf,
+    #[strum(props(default = "1"))]
     E2eeEnabled,
     #[strum(props(default = "1"))]
     MdnsEnabled,
@@ -50,10 +54,12 @@ pub enum Config {
     ConfiguredMailPw,
     ConfiguredMailPort,
     ConfiguredMailSecurity,
+    ConfiguredImapCertificateChecks,
     ConfiguredSendServer,
     ConfiguredSendUser,
     ConfiguredSendPw,
     ConfiguredSendPort,
+    ConfiguredSmtpCertificateChecks,
     ConfiguredServerFlags,
     ConfiguredSendSecurity,
     ConfiguredE2EEEnabled,
@@ -72,13 +78,13 @@ impl Context {
     pub fn get_config(&self, key: Config) -> Option<String> {
         let value = match key {
             Config::Selfavatar => {
-                let rel_path = self.sql.get_config(self, key);
-                rel_path.map(|p| dc_get_abs_path(self, &p).to_str().unwrap().to_string())
+                let rel_path = self.sql.get_raw_config(self, key);
+                rel_path.map(|p| dc_get_abs_path(self, &p).to_string_lossy().into_owned())
             }
             Config::SysVersion => Some((&*DC_VERSION_STR).clone()),
             Config::SysMsgsizeMaxRecommended => Some(format!("{}", 24 * 1024 * 1024 / 4 * 3)),
             Config::SysConfigKeys => Some(get_config_keys_string()),
-            _ => self.sql.get_config(self, key),
+            _ => self.sql.get_raw_config(self, key),
         };
 
         if value.is_some() {
@@ -92,6 +98,16 @@ impl Context {
         }
     }
 
+    pub fn get_config_int(&self, key: Config) -> i32 {
+        self.get_config(key)
+            .and_then(|s| s.parse().ok())
+            .unwrap_or_default()
+    }
+
+    pub fn get_config_bool(&self, key: Config) -> bool {
+        self.get_config_int(key) != 0
+    }
+
     /// Set the given config key.
     /// If `None` is passed as a value the value is cleared and set to the default if there is one.
     pub fn set_config(&self, key: Config, value: Option<&str>) -> Result<(), Error> {
@@ -99,20 +115,20 @@ impl Context {
             Config::Selfavatar if value.is_some() => {
                 let rel_path = std::fs::canonicalize(value.unwrap())?;
                 self.sql
-                    .set_config(self, key, Some(&rel_path.to_string_lossy()))
+                    .set_raw_config(self, key, Some(&rel_path.to_string_lossy()))
             }
             Config::InboxWatch => {
-                let ret = self.sql.set_config(self, key, value);
+                let ret = self.sql.set_raw_config(self, key, value);
                 interrupt_imap_idle(self);
                 ret
             }
             Config::SentboxWatch => {
-                let ret = self.sql.set_config(self, key, value);
+                let ret = self.sql.set_raw_config(self, key, value);
                 interrupt_sentbox_idle(self);
                 ret
             }
             Config::MvboxWatch => {
-                let ret = self.sql.set_config(self, key, value);
+                let ret = self.sql.set_raw_config(self, key, value);
                 interrupt_mvbox_idle(self);
                 ret
             }
@@ -124,9 +140,9 @@ impl Context {
                     value
                 };
 
-                self.sql.set_config(self, key, val)
+                self.sql.set_raw_config(self, key, val)
             }
-            _ => self.sql.set_config(self, key, value),
+            _ => self.sql.set_raw_config(self, key, value),
         }
     }
 }

src/configure/auto_mozilla.rs

@@ -1,10 +1,8 @@
-use libc::free;
 use quick_xml;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText};
 
 use crate::constants::*;
 use crate::context::Context;
-use crate::dc_tools::*;
 use crate::login_param::LoginParam;
 
 use super::read_autoconf_file;
@@ -24,26 +22,22 @@ struct moz_autoconfigure_t<'a> {
     pub tag_config: libc::c_int,
 }
 
-pub unsafe fn moz_autoconfigure(
+pub fn moz_autoconfigure(
     context: &Context,
     url: &str,
     param_in: &LoginParam,
 ) -> Option<LoginParam> {
-    let xml_raw = read_autoconf_file(context, url);
-    if xml_raw.is_null() {
-        return None;
-    }
+    let xml_raw = read_autoconf_file(context, url)?;
 
     // Split address into local part and domain part.
     let p = param_in.addr.find("@");
     if p.is_none() {
-        free(xml_raw as *mut libc::c_void);
         return None;
     }
     let (in_emaillocalpart, in_emaildomain) = param_in.addr.split_at(p.unwrap());
     let in_emaildomain = &in_emaildomain[1..];
 
-    let mut reader = quick_xml::Reader::from_str(as_str(xml_raw));
+    let mut reader = quick_xml::Reader::from_str(&xml_raw);
     reader.trim_text(true);
 
     let mut buf = Vec::new();
@@ -88,11 +82,9 @@ pub unsafe fn moz_autoconfigure(
     {
         let r = moz_ac.out.to_string();
         warn!(context, "Bad or incomplete autoconfig: {}", r,);
-        free(xml_raw as *mut libc::c_void);
         return None;
     }
 
-    free(xml_raw as *mut libc::c_void);
     Some(moz_ac.out)
 }
 

src/configure/auto_outlook.rs

@@ -1,214 +1,157 @@
-use std::ptr;
-
-use libc::free;
 use quick_xml;
-use quick_xml::events::{BytesEnd, BytesStart, BytesText};
+use quick_xml::events::BytesEnd;
 
 use crate::constants::*;
 use crate::context::Context;
-use crate::dc_tools::*;
 use crate::login_param::LoginParam;
 
 use super::read_autoconf_file;
-/* ******************************************************************************
- * Outlook's Autodiscover
- ******************************************************************************/
-#[repr(C)]
-struct outlk_autodiscover_t<'a> {
-    pub in_0: &'a LoginParam,
+
+/// Outlook's Autodiscover
+struct OutlookAutodiscover {
     pub out: LoginParam,
-    pub out_imap_set: libc::c_int,
-    pub out_smtp_set: libc::c_int,
-    pub tag_config: libc::c_int,
-    pub config: [*mut libc::c_char; 6],
-    pub redirect: *mut libc::c_char,
+    pub out_imap_set: bool,
+    pub out_smtp_set: bool,
+    pub config_type: Option<String>,
+    pub config_server: String,
+    pub config_port: i32,
+    pub config_ssl: String,
+    pub config_redirecturl: Option<String>,
 }
 
-pub unsafe fn outlk_autodiscover(
+pub fn outlk_autodiscover(
     context: &Context,
-    url__: &str,
-    param_in: &LoginParam,
+    url: &str,
+    _param_in: &LoginParam,
 ) -> Option<LoginParam> {
-    let mut xml_raw: *mut libc::c_char = ptr::null_mut();
-    let mut url = url__.strdup();
-    let mut outlk_ad = outlk_autodiscover_t {
-        in_0: param_in,
-        out: LoginParam::new(),
-        out_imap_set: 0,
-        out_smtp_set: 0,
-        tag_config: 0,
-        config: [ptr::null_mut(); 6],
-        redirect: ptr::null_mut(),
-    };
-    let ok_to_continue;
-    let mut i = 0;
-    loop {
-        if !(i < 10) {
-            ok_to_continue = true;
-            break;
-        }
-        libc::memset(
-            &mut outlk_ad as *mut outlk_autodiscover_t as *mut libc::c_void,
-            0,
-            ::std::mem::size_of::<outlk_autodiscover_t>(),
-        );
-        xml_raw = read_autoconf_file(context, as_str(url));
-        if xml_raw.is_null() {
-            ok_to_continue = false;
-            break;
-        }
+    let mut url = url.to_string();
+    /* Follow up to 10 xml-redirects (http-redirects are followed in read_autoconf_file() */
+    for _i in 0..10 {
+        let mut outlk_ad = OutlookAutodiscover {
+            out: LoginParam::new(),
+            out_imap_set: false,
+            out_smtp_set: false,
+            config_type: None,
+            config_server: String::new(),
+            config_port: 0,
+            config_ssl: String::new(),
+            config_redirecturl: None,
+        };
 
-        let mut reader = quick_xml::Reader::from_str(as_str(xml_raw));
-        reader.trim_text(true);
+        if let Some(xml_raw) = read_autoconf_file(context, &url) {
+            let mut reader = quick_xml::Reader::from_str(&xml_raw);
+            reader.trim_text(true);
 
-        let mut buf = Vec::new();
+            let mut buf = Vec::new();
 
-        loop {
-            match reader.read_event(&mut buf) {
-                Ok(quick_xml::events::Event::Start(ref e)) => {
-                    outlk_autodiscover_starttag_cb(e, &mut outlk_ad)
+            let mut current_tag: Option<String> = None;
+
+            loop {
+                match reader.read_event(&mut buf) {
+                    Ok(quick_xml::events::Event::Start(ref e)) => {
+                        let tag = String::from_utf8_lossy(e.name()).trim().to_lowercase();
+
+                        if tag == "protocol" {
+                            outlk_ad.config_type = None;
+                            outlk_ad.config_server = String::new();
+                            outlk_ad.config_port = 0;
+                            outlk_ad.config_ssl = String::new();
+                            outlk_ad.config_redirecturl = None;
+
+                            current_tag = None;
+                        } else {
+                            current_tag = Some(tag);
+                        }
+                    }
+                    Ok(quick_xml::events::Event::End(ref e)) => {
+                        outlk_autodiscover_endtag_cb(e, &mut outlk_ad);
+                        current_tag = None;
+                    }
+                    Ok(quick_xml::events::Event::Text(ref e)) => {
+                        let val = e.unescape_and_decode(&reader).unwrap_or_default();
+
+                        if let Some(ref tag) = current_tag {
+                            match tag.as_str() {
+                                "type" => outlk_ad.config_type = Some(val.trim().to_string()),
+                                "server" => outlk_ad.config_server = val.trim().to_string(),
+                                "port" => {
+                                    outlk_ad.config_port = val.trim().parse().unwrap_or_default()
+                                }
+                                "ssl" => outlk_ad.config_ssl = val.trim().to_string(),
+                                "redirecturl" => {
+                                    outlk_ad.config_redirecturl = Some(val.trim().to_string())
+                                }
+                                _ => {}
+                            };
+                        }
+                    }
+                    Err(e) => {
+                        error!(
+                            context,
+                            "Configure xml: Error at position {}: {:?}",
+                            reader.buffer_position(),
+                            e
+                        );
+                    }
+                    Ok(quick_xml::events::Event::Eof) => break,
+                    _ => (),
                 }
-                Ok(quick_xml::events::Event::End(ref e)) => {
-                    outlk_autodiscover_endtag_cb(e, &mut outlk_ad)
-                }
-                Ok(quick_xml::events::Event::Text(ref e)) => {
-                    outlk_autodiscover_text_cb(e, &mut outlk_ad, &reader)
-                }
-                Err(e) => {
-                    error!(
-                        context,
-                        "Configure xml: Error at position {}: {:?}",
-                        reader.buffer_position(),
-                        e
-                    );
-                }
-                Ok(quick_xml::events::Event::Eof) => break,
-                _ => (),
+                buf.clear();
             }
-            buf.clear();
-        }
-
-        if !(!outlk_ad.config[5].is_null()
-            && 0 != *outlk_ad.config[5usize].offset(0isize) as libc::c_int)
-        {
-            ok_to_continue = true;
-            break;
-        }
-        free(url as *mut libc::c_void);
-        url = dc_strdup(outlk_ad.config[5usize]);
-
-        outlk_clean_config(&mut outlk_ad);
-        free(xml_raw as *mut libc::c_void);
-        xml_raw = ptr::null_mut();
-        i += 1;
-    }
-
-    if ok_to_continue {
-        if outlk_ad.out.mail_server.is_empty()
-            || outlk_ad.out.mail_port == 0
-            || outlk_ad.out.send_server.is_empty()
-            || outlk_ad.out.send_port == 0
-        {
-            let r = outlk_ad.out.to_string();
-            warn!(context, "Bad or incomplete autoconfig: {}", r,);
-            free(url as *mut libc::c_void);
-            free(xml_raw as *mut libc::c_void);
-            outlk_clean_config(&mut outlk_ad);
 
+            // XML redirect via redirecturl
+            if outlk_ad.config_redirecturl.is_none()
+                || outlk_ad.config_redirecturl.as_ref().unwrap().is_empty()
+            {
+                if outlk_ad.out.mail_server.is_empty()
+                    || outlk_ad.out.mail_port == 0
+                    || outlk_ad.out.send_server.is_empty()
+                    || outlk_ad.out.send_port == 0
+                {
+                    let r = outlk_ad.out.to_string();
+                    warn!(context, "Bad or incomplete autoconfig: {}", r,);
+                    return None;
+                }
+                return Some(outlk_ad.out);
+            } else {
+                url = outlk_ad.config_redirecturl.unwrap();
+            }
+        } else {
             return None;
         }
     }
-    free(url as *mut libc::c_void);
-    free(xml_raw as *mut libc::c_void);
-    outlk_clean_config(&mut outlk_ad);
-    Some(outlk_ad.out)
+    None
 }
 
-unsafe fn outlk_clean_config(mut outlk_ad: *mut outlk_autodiscover_t) {
-    for i in 0..6 {
-        free((*outlk_ad).config[i] as *mut libc::c_void);
-        (*outlk_ad).config[i] = ptr::null_mut();
-    }
-}
-
-fn outlk_autodiscover_text_cb<B: std::io::BufRead>(
-    event: &BytesText,
-    outlk_ad: &mut outlk_autodiscover_t,
-    reader: &quick_xml::Reader<B>,
-) {
-    let val = event.unescape_and_decode(reader).unwrap_or_default();
-
-    unsafe {
-        free(outlk_ad.config[outlk_ad.tag_config as usize].cast());
-        outlk_ad.config[outlk_ad.tag_config as usize] = val.trim().strdup();
-    }
-}
-
-unsafe fn outlk_autodiscover_endtag_cb(event: &BytesEnd, outlk_ad: &mut outlk_autodiscover_t) {
+fn outlk_autodiscover_endtag_cb(event: &BytesEnd, outlk_ad: &mut OutlookAutodiscover) {
     let tag = String::from_utf8_lossy(event.name()).trim().to_lowercase();
 
     if tag == "protocol" {
-        if !outlk_ad.config[1].is_null() {
-            let port = dc_atoi_null_is_0(outlk_ad.config[3]);
-            let ssl_on = (!outlk_ad.config[4].is_null()
-                && strcasecmp(
-                    outlk_ad.config[4],
-                    b"on\x00" as *const u8 as *const libc::c_char,
-                ) == 0) as libc::c_int;
-            let ssl_off = (!outlk_ad.config[4].is_null()
-                && strcasecmp(
-                    outlk_ad.config[4],
-                    b"off\x00" as *const u8 as *const libc::c_char,
-                ) == 0) as libc::c_int;
-            if strcasecmp(
-                outlk_ad.config[1],
-                b"imap\x00" as *const u8 as *const libc::c_char,
-            ) == 0
-                && outlk_ad.out_imap_set == 0
-            {
-                outlk_ad.out.mail_server = to_string(outlk_ad.config[2]);
+        if let Some(type_) = &outlk_ad.config_type {
+            let port = outlk_ad.config_port;
+            let ssl_on = outlk_ad.config_ssl == "on";
+            let ssl_off = outlk_ad.config_ssl == "off";
+            if type_ == "imap" && !outlk_ad.out_imap_set {
+                outlk_ad.out.mail_server =
+                    std::mem::replace(&mut outlk_ad.config_server, String::new());
                 outlk_ad.out.mail_port = port;
-                if 0 != ssl_on {
+                if ssl_on {
                     outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_SSL as i32
-                } else if 0 != ssl_off {
+                } else if ssl_off {
                     outlk_ad.out.server_flags |= DC_LP_IMAP_SOCKET_PLAIN as i32
                 }
-                outlk_ad.out_imap_set = 1
-            } else if strcasecmp(
-                outlk_ad.config[1usize],
-                b"smtp\x00" as *const u8 as *const libc::c_char,
-            ) == 0
-                && outlk_ad.out_smtp_set == 0
-            {
-                outlk_ad.out.send_server = to_string(outlk_ad.config[2]);
-                outlk_ad.out.send_port = port;
-                if 0 != ssl_on {
+                outlk_ad.out_imap_set = true
+            } else if type_ == "smtp" && !outlk_ad.out_smtp_set {
+                outlk_ad.out.send_server =
+                    std::mem::replace(&mut outlk_ad.config_server, String::new());
+                outlk_ad.out.send_port = outlk_ad.config_port;
+                if ssl_on {
                     outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_SSL as i32
-                } else if 0 != ssl_off {
+                } else if ssl_off {
                     outlk_ad.out.server_flags |= DC_LP_SMTP_SOCKET_PLAIN as i32
                 }
-                outlk_ad.out_smtp_set = 1
+                outlk_ad.out_smtp_set = true
             }
         }
-        outlk_clean_config(outlk_ad);
     }
-    outlk_ad.tag_config = 0;
-}
-
-fn outlk_autodiscover_starttag_cb(event: &BytesStart, outlk_ad: &mut outlk_autodiscover_t) {
-    let tag = String::from_utf8_lossy(event.name()).trim().to_lowercase();
-
-    if tag == "protocol" {
-        unsafe { outlk_clean_config(outlk_ad) };
-    } else if tag == "type" {
-        outlk_ad.tag_config = 1
-    } else if tag == "server" {
-        outlk_ad.tag_config = 2
-    } else if tag == "port" {
-        outlk_ad.tag_config = 3
-    } else if tag == "ssl" {
-        outlk_ad.tag_config = 4
-    } else if tag == "redirecturl" {
-        outlk_ad.tag_config = 5
-    };
 }

src/configure/mod.rs

@@ -1,5 +1,6 @@
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 
+use crate::config::Config;
 use crate::constants::*;
 use crate::context::Context;
 use crate::dc_tools::*;
@@ -27,7 +28,7 @@ macro_rules! progress {
 
 // connect
 pub unsafe fn configure(context: &Context) {
-    if dc_has_ongoing(context) {
+    if context.has_ongoing() {
         warn!(context, "There is already another ongoing process running.",);
         return;
     }
@@ -37,7 +38,7 @@ pub unsafe fn configure(context: &Context) {
 
 /// Check if the context is already configured.
 pub fn dc_is_configured(context: &Context) -> bool {
-    context.sql.get_config_bool(context, "configured")
+    context.sql.get_raw_config_bool(context, "configured")
 }
 
 /*******************************************************************************
@@ -52,7 +53,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
     let mut ongoing_allocated_here = false;
 
     let mut param_autoconfig: Option<LoginParam> = None;
-    if dc_alloc_ongoing(context) {
+    if context.alloc_ongoing() {
         ongoing_allocated_here = true;
         if !context.sql.is_open() {
             error!(context, "Cannot configure, database not opened.",);
@@ -73,9 +74,6 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
             context.smtp.clone().lock().unwrap().disconnect();
             info!(context, "Configure ...",);
 
-            let s_a = context.running_state.clone();
-            let s = s_a.read().unwrap();
-
             // Variables that are shared between steps:
             let mut param = LoginParam::from_database(context, "");
             // need all vars here to be mutable because rust thinks the same step could be called multiple times
@@ -87,7 +85,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
 
             const STEP_3_INDEX: u8 = 13;
             let mut step_counter: u8 = 0;
-            while !s.shall_stop_ongoing {
+            while !context.shall_stop_ongoing() {
                 step_counter = step_counter + 1;
 
                 let success = match step_counter {
@@ -113,7 +111,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                                 param.addr = oauth2_addr;
                                 context
                                     .sql
-                                    .set_config(context, "addr", Some(param.addr.as_str()))
+                                    .set_raw_config(context, "addr", Some(param.addr.as_str()))
                                     .ok();
                             }
                             progress!(context, 20);
@@ -352,12 +350,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                                 ok_to_continue8 = true;
                                 break;
                             }
-                            if !param_autoconfig.is_none() {
+                            if param_autoconfig.is_some() {
                                 ok_to_continue8 = false;
                                 break;
                             }
                             // probe STARTTLS/993
-                            if s.shall_stop_ongoing {
+                            if context.shall_stop_ongoing() {
                                 ok_to_continue8 = false;
                                 break;
                             }
@@ -371,7 +369,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                                 break;
                             }
                             // probe STARTTLS/143
-                            if s.shall_stop_ongoing {
+                            if context.shall_stop_ongoing() {
                                 ok_to_continue8 = false;
                                 break;
                             }
@@ -388,7 +386,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                                 break;
                             }
                             // next probe round with only the localpart of the email-address as the loginname
-                            if s.shall_stop_ongoing {
+                            if context.shall_stop_ongoing() {
                                 ok_to_continue8 = false;
                                 break;
                             }
@@ -423,9 +421,9 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                             .unwrap()
                             .connect(context, &param)
                         {
-                            if !param_autoconfig.is_none() {
+                            if param_autoconfig.is_some() {
                                 success = false;
-                            } else if s.shall_stop_ongoing {
+                            } else if context.shall_stop_ongoing() {
                                 success = false;
                             } else {
                                 progress!(context, 850);
@@ -441,7 +439,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                                     .unwrap()
                                     .connect(context, &param)
                                 {
-                                    if s.shall_stop_ongoing {
+                                    if context.shall_stop_ongoing() {
                                         success = false;
                                     } else {
                                         progress!(context, 860);
@@ -476,15 +474,8 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                     }
                     16 => {
                         progress!(context, 900);
-                        let flags: libc::c_int = if 0
-                            != context
-                                .sql
-                                .get_config_int(context, "mvbox_watch")
-                                .unwrap_or_else(|| 1)
-                            || 0 != context
-                                .sql
-                                .get_config_int(context, "mvbox_move")
-                                .unwrap_or_else(|| 1)
+                        let flags: libc::c_int = if context.get_config_bool(Config::MvboxWatch)
+                            || context.get_config_bool(Config::MvboxMove)
                         {
                             DC_CREATE_MVBOX as i32
                         } else {
@@ -507,7 +498,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                             )
                             .ok();
 
-                        context.sql.set_config_bool(context, "configured", true);
+                        context.sql.set_raw_config_bool(context, "configured", true);
                         true
                     }
                     18 => {
@@ -559,47 +550,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
     }
     */
     if ongoing_allocated_here {
-        dc_free_ongoing(context);
+        context.free_ongoing();
     }
 
     progress!(context, if success { 1000 } else { 0 });
 }
 
-/*******************************************************************************
- * Ongoing process allocation/free/check
- ******************************************************************************/
-
-pub fn dc_alloc_ongoing(context: &Context) -> bool {
-    if dc_has_ongoing(context) {
-        warn!(context, "There is already another ongoing process running.",);
-
-        false
-    } else {
-        let s_a = context.running_state.clone();
-        let mut s = s_a.write().unwrap();
-
-        s.ongoing_running = true;
-        s.shall_stop_ongoing = false;
-
-        true
-    }
-}
-
-pub fn dc_free_ongoing(context: &Context) {
-    let s_a = context.running_state.clone();
-    let mut s = s_a.write().unwrap();
-
-    s.ongoing_running = false;
-    s.shall_stop_ongoing = true;
-}
-
-fn dc_has_ongoing(context: &Context) -> bool {
-    let s_a = context.running_state.clone();
-    let s = s_a.read().unwrap();
-
-    s.ongoing_running || !s.shall_stop_ongoing
-}
-
 /*******************************************************************************
  * Connect to configured account
  ******************************************************************************/
@@ -608,12 +564,7 @@ pub fn dc_connect_to_configured_imap(context: &Context, imap: &Imap) -> libc::c_
 
     if imap.is_connected() {
         ret_connected = 1
-    } else if context
-        .sql
-        .get_config_int(context, "configured")
-        .unwrap_or_default()
-        == 0
-    {
+    } else if !context.sql.get_raw_config_bool(context, "configured") {
         warn!(context, "Not configured, cannot connect.",);
     } else {
         let param = LoginParam::from_database(context, "configured_");
@@ -631,20 +582,7 @@ pub fn dc_connect_to_configured_imap(context: &Context, imap: &Imap) -> libc::c_
  * Configure a Context
  ******************************************************************************/
 
-/// Signal an ongoing process to stop.
-pub fn dc_stop_ongoing_process(context: &Context) {
-    let s_a = context.running_state.clone();
-    let mut s = s_a.write().unwrap();
-
-    if s.ongoing_running && !s.shall_stop_ongoing {
-        info!(context, "Signaling the ongoing process to stop ASAP.",);
-        s.shall_stop_ongoing = true;
-    } else {
-        info!(context, "No ongoing process to stop.",);
-    };
-}
-
-pub fn read_autoconf_file(context: &Context, url: &str) -> *mut libc::c_char {
+pub fn read_autoconf_file(context: &Context, url: &str) -> Option<String> {
     info!(context, "Testing {} ...", url);
 
     match reqwest::Client::new()
@@ -652,11 +590,11 @@ pub fn read_autoconf_file(context: &Context, url: &str) -> *mut libc::c_char {
         .send()
         .and_then(|mut res| res.text())
     {
-        Ok(res) => unsafe { res.strdup() },
+        Ok(res) => Some(res),
         Err(_err) => {
             info!(context, "Can\'t read file.",);
 
-            std::ptr::null_mut()
+            None
         }
     }
 }

src/constants.rs

@@ -25,7 +25,6 @@ impl Default for MoveState {
 
 // some defaults
 const DC_E2EE_DEFAULT_ENABLED: i32 = 1;
-pub const DC_MDNS_DEFAULT_ENABLED: i32 = 1;
 const DC_INBOX_WATCH_DEFAULT: i32 = 1;
 const DC_SENTBOX_WATCH_DEFAULT: i32 = 1;
 const DC_MVBOX_WATCH_DEFAULT: i32 = 1;
@@ -195,6 +194,11 @@ pub enum Viewtype {
     /// and retrieved via dc_msg_get_file(), dc_msg_get_width(), dc_msg_get_height().
     Gif = 21,
 
+    /// Message containing a sticker, similar to image.
+    /// If possible, the ui should display the image without borders in a transparent way.
+    /// A click on a sticker will offer to install the sticker set in some future.
+    Sticker = 23,
+
     /// Message containing an Audio file.
     /// File and duration are set via dc_msg_set_file(), dc_msg_set_duration()
     /// and retrieved via dc_msg_get_file(), dc_msg_get_duration().
@@ -299,7 +303,8 @@ const DC_STR_MSGACTIONBYME: usize = 63;
 const DC_STR_MSGLOCATIONENABLED: usize = 64;
 const DC_STR_MSGLOCATIONDISABLED: usize = 65;
 const DC_STR_LOCATION: usize = 66;
-const DC_STR_COUNT: usize = 66;
+const DC_STR_STICKER: usize = 67;
+const DC_STR_COUNT: usize = 67;
 
 pub const DC_JOB_DELETE_MSG_ON_IMAP: i32 = 110;
 

src/contact.rs

@@ -390,20 +390,18 @@ impl Contact {
                 }
                 sth_modified = Modifier::Modified;
             }
+        } else if sql::execute(
+            context,
+            &context.sql,
+            "INSERT INTO contacts (name, addr, origin) VALUES(?, ?, ?);",
+            params![name.as_ref(), addr, origin,],
+        )
+        .is_ok()
+        {
+            row_id = sql::get_rowid(context, &context.sql, "contacts", "addr", addr);
+            sth_modified = Modifier::Created;
         } else {
-            if sql::execute(
-                context,
-                &context.sql,
-                "INSERT INTO contacts (name, addr, origin) VALUES(?, ?, ?);",
-                params![name.as_ref(), addr, origin,],
-            )
-            .is_ok()
-            {
-                row_id = sql::get_rowid(context, &context.sql, "contacts", "addr", addr);
-                sth_modified = Modifier::Created;
-            } else {
-                error!(context, "Cannot add contact.");
-            }
+            error!(context, "Cannot add contact.");
         }
 
         Ok((row_id, sth_modified))
@@ -827,7 +825,7 @@ impl Contact {
         if let Ok(contact) = Contact::load_from_db(context, contact_id) {
             if !contact.addr.is_empty() {
                 let normalized_addr = addr_normalize(addr.as_ref());
-                if &contact.addr == &normalized_addr {
+                if contact.addr == normalized_addr {
                     return true;
                 }
             }
@@ -963,9 +961,9 @@ pub fn normalize_name(full_name: impl AsRef<str>) -> String {
     if len > 0 {
         let firstchar = full_name.as_bytes()[0];
         let lastchar = full_name.as_bytes()[len - 1];
-        if firstchar == '\'' as u8 && lastchar == '\'' as u8
-            || firstchar == '\"' as u8 && lastchar == '\"' as u8
-            || firstchar == '<' as u8 && lastchar == '>' as u8
+        if firstchar == b'\'' && lastchar == b'\''
+            || firstchar == b'\"' && lastchar == b'\"'
+            || firstchar == b'<' && lastchar == b'>'
         {
             full_name = &full_name[1..len - 1];
         }

src/context.rs

@@ -8,6 +8,7 @@ use std::sync::{Arc, Condvar, Mutex, RwLock};
 use libc::uintptr_t;
 
 use crate::chat::*;
+use crate::config::Config;
 use crate::constants::*;
 use crate::contact::*;
 use crate::dc_tools::{dc_copy_file, dc_derive_safe_stem_ext};
@@ -67,7 +68,7 @@ pub struct Context {
 #[derive(Debug, PartialEq, Eq)]
 pub struct RunningState {
     pub ongoing_running: bool,
-    pub shall_stop_ongoing: bool,
+    shall_stop_ongoing: bool,
 }
 
 /// Return some info about deltachat-core
@@ -207,7 +208,9 @@ impl Context {
                 .open(&path)
             {
                 file.write_all(data)?;
-                return Ok(format!("$BLOBDIR/{}", candidate_basename));
+                let db_entry = format!("$BLOBDIR/{}", candidate_basename);
+                self.call_cb(Event::NewBlobFile(db_entry.clone()));
+                return Ok(db_entry);
             }
         }
         bail!("out of luck to create new blob file");
@@ -217,31 +220,84 @@ impl Context {
         (*self.cb)(self, event)
     }
 
+    /*******************************************************************************
+     * Ongoing process allocation/free/check
+     ******************************************************************************/
+
+    pub fn alloc_ongoing(&self) -> bool {
+        if self.has_ongoing() {
+            warn!(self, "There is already another ongoing process running.",);
+
+            false
+        } else {
+            let s_a = self.running_state.clone();
+            let mut s = s_a.write().unwrap();
+
+            s.ongoing_running = true;
+            s.shall_stop_ongoing = false;
+
+            true
+        }
+    }
+
+    pub fn free_ongoing(&self) {
+        let s_a = self.running_state.clone();
+        let mut s = s_a.write().unwrap();
+
+        s.ongoing_running = false;
+        s.shall_stop_ongoing = true;
+    }
+
+    pub fn has_ongoing(&self) -> bool {
+        let s_a = self.running_state.clone();
+        let s = s_a.read().unwrap();
+
+        s.ongoing_running || !s.shall_stop_ongoing
+    }
+
+    /// Signal an ongoing process to stop.
+    pub fn stop_ongoing(&self) {
+        let s_a = self.running_state.clone();
+        let mut s = s_a.write().unwrap();
+
+        if s.ongoing_running && !s.shall_stop_ongoing {
+            info!(self, "Signaling the ongoing process to stop ASAP.",);
+            s.shall_stop_ongoing = true;
+        } else {
+            info!(self, "No ongoing process to stop.",);
+        };
+    }
+
+    pub fn shall_stop_ongoing(&self) -> bool {
+        self.running_state
+            .clone()
+            .read()
+            .unwrap()
+            .shall_stop_ongoing
+    }
+
+    /*******************************************************************************
+     * UI chat/message related API
+     ******************************************************************************/
+
     pub fn get_info(&self) -> HashMap<&'static str, String> {
         let unset = "0";
         let l = LoginParam::from_database(self, "");
         let l2 = LoginParam::from_database(self, "configured_");
-        let displayname = self.sql.get_config(self, "displayname");
+        let displayname = self.get_config(Config::Displayname);
         let chats = get_chat_cnt(self) as usize;
         let real_msgs = message::get_real_msg_cnt(self) as usize;
         let deaddrop_msgs = message::get_deaddrop_msg_cnt(self) as usize;
         let contacts = Contact::get_real_cnt(self) as usize;
-        let is_configured = self
-            .sql
-            .get_config_int(self, "configured")
-            .unwrap_or_default();
+        let is_configured = self.get_config_int(Config::Configured);
         let dbversion = self
             .sql
-            .get_config_int(self, "dbversion")
+            .get_raw_config_int(self, "dbversion")
             .unwrap_or_default();
-        let e2ee_enabled = self
-            .sql
-            .get_config_int(self, "e2ee_enabled")
-            .unwrap_or_else(|| 1);
-        let mdns_enabled = self
-            .sql
-            .get_config_int(self, "mdns_enabled")
-            .unwrap_or_else(|| 1);
+
+        let e2ee_enabled = self.get_config_int(Config::E2eeEnabled);
+        let mdns_enabled = self.get_config_int(Config::MdnsEnabled);
+        let bcc_self = self.get_config_int(Config::BccSelf);
 
         let prv_key_cnt: Option<isize> =
             self.sql
@@ -259,33 +315,22 @@ impl Context {
             "<Not yet calculated>".into()
         };
 
-        let inbox_watch = self
-            .sql
-            .get_config_int(self, "inbox_watch")
-            .unwrap_or_else(|| 1);
-        let sentbox_watch = self
-            .sql
-            .get_config_int(self, "sentbox_watch")
-            .unwrap_or_else(|| 1);
-        let mvbox_watch = self
-            .sql
-            .get_config_int(self, "mvbox_watch")
-            .unwrap_or_else(|| 1);
-        let mvbox_move = self
-            .sql
-            .get_config_int(self, "mvbox_move")
-            .unwrap_or_else(|| 1);
+        let inbox_watch = self.get_config_int(Config::InboxWatch);
+        let sentbox_watch = self.get_config_int(Config::SentboxWatch);
+        let mvbox_watch = self.get_config_int(Config::MvboxWatch);
+        let mvbox_move = self.get_config_int(Config::MvboxMove);
         let folders_configured = self
             .sql
-            .get_config_int(self, "folders_configured")
+            .get_raw_config_int(self, "folders_configured")
             .unwrap_or_default();
+
         let configured_sentbox_folder = self
             .sql
-            .get_config(self, "configured_sentbox_folder")
+            .get_raw_config(self, "configured_sentbox_folder")
             .unwrap_or_else(|| "<unset>".to_string());
         let configured_mvbox_folder = self
             .sql
-            .get_config(self, "configured_mvbox_folder")
+            .get_raw_config(self, "configured_mvbox_folder")
             .unwrap_or_else(|| "<unset>".to_string());
 
         let mut res = get_info();
@@ -309,6 +354,7 @@ impl Context {
         res.insert("configured_mvbox_folder", configured_mvbox_folder);
         res.insert("mdns_enabled", mdns_enabled.to_string());
         res.insert("e2ee_enabled", e2ee_enabled.to_string());
+        res.insert("bcc_self", bcc_self.to_string());
         res.insert(
             "private_key_count",
             prv_key_cnt.unwrap_or_default().to_string(),
@@ -344,7 +390,7 @@ impl Context {
                     Ok(ret)
                 },
             )
-            .unwrap()
+            .unwrap_or_default()
     }
 
     #[allow(non_snake_case)]
@@ -388,7 +434,7 @@ impl Context {
     }
 
     pub fn is_sentbox(&self, folder_name: impl AsRef<str>) -> bool {
-        let sentbox_name = self.sql.get_config(self, "configured_sentbox_folder");
+        let sentbox_name = self.sql.get_raw_config(self, "configured_sentbox_folder");
         if let Some(name) = sentbox_name {
             name == folder_name.as_ref()
         } else {
@@ -397,7 +443,7 @@ impl Context {
     }
 
     pub fn is_mvbox(&self, folder_name: impl AsRef<str>) -> bool {
-        let mvbox_name = self.sql.get_config(self, "configured_mvbox_folder");
+        let mvbox_name = self.sql.get_raw_config(self, "configured_mvbox_folder");
 
         if let Some(name) = mvbox_name {
             name == folder_name.as_ref()
@@ -407,12 +453,7 @@ impl Context {
     }
 
     pub fn do_heuristics_moves(&self, folder: &str, msg_id: u32) {
-        if self
-            .sql
-            .get_config_int(self, "mvbox_move")
-            .unwrap_or_else(|| 1)
-            == 0
-        {
+        if !self.get_config_bool(Config::MvboxMove) {
             return;
         }
 

src/dc_mimeparser.rs

@@ -11,7 +11,6 @@ use mmime::mailmime::content::*;
 use mmime::mailmime::disposition::*;
 use mmime::mailmime::types::*;
 use mmime::mailmime::*;
-use mmime::mmapstring::*;
 use mmime::other::*;
 
 use crate::constants::Viewtype;
@@ -25,6 +24,7 @@ use crate::error::Error;
 use crate::location;
 use crate::param::*;
 use crate::stock::StockMessage;
+use crate::wrapmime;
 
 #[derive(Debug)]
 pub struct MimeParser<'a> {
@@ -105,15 +105,15 @@ impl<'a> MimeParser<'a> {
         }
     }
 
-    pub unsafe fn parse(&mut self, body: &[u8]) -> Result<(), Error> {
+    pub fn parse(&mut self, body: &[u8]) -> Result<(), Error> {
         let mut index = 0;
 
-        let r = mailmime_parse(
+        let r = unsafe { mailmime_parse(
             body.as_ptr() as *const libc::c_char,
             body.len(),
             &mut index,
             &mut self.mimeroot,
-        );
+        ) };
 
         if r == MAILIMF_NO_ERROR as libc::c_int && !self.mimeroot.is_null() {
             let (encrypted, signatures, gossipped_addr) =
@@ -121,13 +121,13 @@ impl<'a> MimeParser<'a> {
             self.encrypted = encrypted;
             self.signatures = signatures;
             self.gossipped_addr = gossipped_addr;
-            self.parse_mime_recursive(self.mimeroot);
+            unsafe { self.parse_mime_recursive(self.mimeroot) } ;
 
             if let Some(field) = self.lookup_field("Subject") {
-                if (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
-                    let subj = (*(*field).fld_data.fld_subject).sbj_value;
+                if unsafe { (*field).fld_type } == MAILIMF_FIELD_SUBJECT as libc::c_int {
+                    let subj = unsafe { (*(*field).fld_data.fld_subject).sbj_value };
 
-                    self.subject = as_opt_str(subj).map(dc_decode_header_words_safe);
+                    self.subject = as_opt_str(subj).map(dc_decode_header_words);
                 }
             }
 
@@ -164,21 +164,17 @@ impl<'a> MimeParser<'a> {
                         }
                     }
                 }
-            } else {
-                if let Some(optional_field) = self.lookup_optional_field("Chat-Content") {
-                    if optional_field == "location-streaming-enabled" {
-                        self.is_system_message = SystemMessage::LocationStreamingEnabled;
-                    }
+            } else if let Some(optional_field) = self.lookup_optional_field("Chat-Content") {
+                if optional_field == "location-streaming-enabled" {
+                    self.is_system_message = SystemMessage::LocationStreamingEnabled;
                 }
             }
             if self.lookup_field("Chat-Group-Image").is_some() && !self.parts.is_empty() {
                 let textpart = &self.parts[0];
-                if textpart.typ == Viewtype::Text {
-                    if self.parts.len() >= 2 {
-                        let imgpart = &mut self.parts[1];
-                        if imgpart.typ == Viewtype::Image {
-                            imgpart.is_meta = true;
-                        }
+                if textpart.typ == Viewtype::Text && self.parts.len() >= 2 {
+                    let imgpart = &mut self.parts[1];
+                    if imgpart.typ == Viewtype::Image {
+                        imgpart.is_meta = true;
                     }
                 }
             }
@@ -189,6 +185,7 @@ impl<'a> MimeParser<'a> {
                     textpart.typ == Viewtype::Text
                         && (filepart.typ == Viewtype::Image
                             || filepart.typ == Viewtype::Gif
+                            || filepart.typ == Viewtype::Sticker
                             || filepart.typ == Viewtype::Audio
                             || filepart.typ == Viewtype::Voice
                             || filepart.typ == Viewtype::Video
@@ -256,6 +253,14 @@ impl<'a> MimeParser<'a> {
                         part_mut.typ = Viewtype::Voice;
                     }
                 }
+                if self.parts[0].typ == Viewtype::Image {
+                    if let Some(content_type) = self.lookup_optional_field("Chat-Content") {
+                        if content_type == "sticker" {
+                            let part_mut = &mut self.parts[0];
+                            part_mut.typ = Viewtype::Sticker;
+                        }
+                    }
+                }
                 let part = &self.parts[0];
                 if part.typ == Viewtype::Audio
                     || part.typ == Viewtype::Voice
@@ -277,23 +282,23 @@ impl<'a> MimeParser<'a> {
                     if self.get_last_nonmeta().is_some() {
                         let mut mb_list: *mut mailimf_mailbox_list = ptr::null_mut();
                         let mut index_0 = 0;
-                        let dn_field_c = CString::new(dn_field).unwrap();
+                        let dn_field_c = CString::new(dn_field).unwrap_or_default();
 
-                        if mailimf_mailbox_list_parse(
+                        if unsafe { mailimf_mailbox_list_parse(
                             dn_field_c.as_ptr(),
                             strlen(dn_field_c.as_ptr()),
                             &mut index_0,
                             &mut mb_list,
-                        ) == MAILIMF_NO_ERROR as libc::c_int
+                        ) } == MAILIMF_NO_ERROR as libc::c_int
                             && !mb_list.is_null()
                         {
-                            if let Some(dn_to_addr) = mailimf_find_first_addr(mb_list) {
+                            if let Some(dn_to_addr) = wrapmime::mailimf_find_first_addr(mb_list) {
                                 if let Some(from_field) = self.lookup_field("From") {
-                                    if (*from_field).fld_type == MAILIMF_FIELD_FROM as libc::c_int
-                                        && !(*from_field).fld_data.fld_from.is_null()
+                                    if unsafe { (*from_field).fld_type == MAILIMF_FIELD_FROM as libc::c_int
+                                        && !(*from_field).fld_data.fld_from.is_null() }
                                     {
-                                        let from_addr = mailimf_find_first_addr(
-                                            (*(*from_field).fld_data.fld_from).frm_mb_list,
+                                        let from_addr = wrapmime::mailimf_find_first_addr(
+                                            unsafe { (*(*from_field).fld_data.fld_from).frm_mb_list },
                                         );
                                         if let Some(from_addr) = from_addr {
                                             if from_addr == dn_to_addr {
@@ -305,7 +310,7 @@ impl<'a> MimeParser<'a> {
                                     }
                                 }
                             }
-                            mailimf_mailbox_list_free(mb_list);
+                            unsafe { mailimf_mailbox_list_free(mb_list) };
                         }
                     }
                 }
@@ -590,7 +595,7 @@ impl<'a> MimeParser<'a> {
             return false;
         }
 
-        let mut decoded_data = match mailmime_transfer_decode(mime) {
+        let mut decoded_data = match wrapmime::mailmime_transfer_decode(mime) {
             Ok(decoded_data) => decoded_data,
             Err(_) => {
                 // Note that it's now always an error - might be no data
@@ -601,7 +606,6 @@ impl<'a> MimeParser<'a> {
         let old_part_count = self.parts.len();
 
         /* regard `Content-Transfer-Encoding:` */
-        let mut ok_to_continue = true;
         let mut desired_filename = String::default();
         let mut simplifier: Option<Simplify> = None;
         match mime_type {
@@ -616,15 +620,14 @@ impl<'a> MimeParser<'a> {
                     && strcmp(charset, b"UTF-8\x00" as *const u8 as *const libc::c_char) != 0i32
                 {
                     if let Some(encoding) =
-                        Charset::for_label(CStr::from_ptr(charset).to_str().unwrap().as_bytes())
+                        Charset::for_label(CStr::from_ptr(charset).to_string_lossy().as_bytes())
                     {
                         let (res, _, _) = encoding.decode(&decoded_data);
                         if res.is_empty() {
                             /* no error - but nothing to add */
-                            ok_to_continue = false;
-                        } else {
-                            decoded_data = res.as_bytes().to_vec()
+                            return false;
                         }
+                        decoded_data = res.as_bytes().to_vec()
                     } else {
                         warn!(
                             self.context,
@@ -634,31 +637,29 @@ impl<'a> MimeParser<'a> {
                         );
                     }
                 }
-                if ok_to_continue {
-                    /* check header directly as is_send_by_messenger is not yet set up */
-                    let is_msgrmsg = self.lookup_optional_field("Chat-Version").is_some();
+                /* check header directly as is_send_by_messenger is not yet set up */
+                let is_msgrmsg = self.lookup_optional_field("Chat-Version").is_some();
 
-                    let simplified_txt = if decoded_data.is_empty() {
-                        "".into()
-                    } else {
-                        let input = std::string::String::from_utf8_lossy(&decoded_data);
-                        let is_html = mime_type == 70;
+                let simplified_txt = if decoded_data.is_empty() {
+                    "".into()
+                } else {
+                    let input = std::string::String::from_utf8_lossy(&decoded_data);
+                    let is_html = mime_type == 70;
 
-                        simplifier.unwrap().simplify(&input, is_html, is_msgrmsg)
-                    };
-                    if !simplified_txt.is_empty() {
-                        let mut part = Part::default();
-                        part.typ = Viewtype::Text;
-                        part.mimetype = mime_type;
-                        part.msg = Some(simplified_txt);
-                        part.msg_raw =
-                            Some(std::string::String::from_utf8_lossy(&decoded_data).to_string());
-                        self.do_add_single_part(part);
-                    }
+                    simplifier.unwrap().simplify(&input, is_html, is_msgrmsg)
+                };
+                if !simplified_txt.is_empty() {
+                    let mut part = Part::default();
+                    part.typ = Viewtype::Text;
+                    part.mimetype = mime_type;
+                    part.msg = Some(simplified_txt);
+                    part.msg_raw =
+                        Some(std::string::String::from_utf8_lossy(&decoded_data).to_string());
+                    self.do_add_single_part(part);
+                }
 
-                    if simplifier.unwrap().is_forwarded {
-                        self.is_forwarded = true;
-                    }
+                if simplifier.unwrap().is_forwarded {
+                    self.is_forwarded = true;
                 }
             }
             DC_MIMETYPE_IMAGE
@@ -704,7 +705,7 @@ impl<'a> MimeParser<'a> {
                                         // might be a wrongly encoded filename
                                         let s = to_string_lossy((*dsp_param).pa_data.pa_filename);
                                         // this is used only if the parts buffer stays empty
-                                        desired_filename = dc_decode_header_words_safe(&s)
+                                        desired_filename = dc_decode_header_words(&s)
                                     }
                                 }
                             }
@@ -733,33 +734,29 @@ impl<'a> MimeParser<'a> {
                         desired_filename =
                             format!("file.{}", as_str((*(*mime).mm_content_type).ct_subtype));
                     } else {
-                        ok_to_continue = false;
+                        return false;
                     }
                 }
-                if ok_to_continue {
-                    if desired_filename.starts_with("location")
-                        && desired_filename.ends_with(".kml")
-                    {
-                        if !decoded_data.is_empty() {
-                            let d = std::string::String::from_utf8_lossy(&decoded_data);
-                            self.location_kml = location::Kml::parse(self.context, &d).ok();
-                        }
-                    } else if desired_filename.starts_with("message")
-                        && desired_filename.ends_with(".kml")
-                    {
-                        if !decoded_data.is_empty() {
-                            let d = std::string::String::from_utf8_lossy(&decoded_data);
-                            self.message_kml = location::Kml::parse(self.context, &d).ok();
-                        }
-                    } else if !decoded_data.is_empty() {
-                        self.do_add_single_file_part(
-                            msg_type,
-                            mime_type,
-                            raw_mime.as_ref(),
-                            &decoded_data,
-                            &desired_filename,
-                        );
+                if desired_filename.starts_with("location") && desired_filename.ends_with(".kml") {
+                    if !decoded_data.is_empty() {
+                        let d = std::string::String::from_utf8_lossy(&decoded_data);
+                        self.location_kml = location::Kml::parse(self.context, &d).ok();
                     }
+                } else if desired_filename.starts_with("message")
+                    && desired_filename.ends_with(".kml")
+                {
+                    if !decoded_data.is_empty() {
+                        let d = std::string::String::from_utf8_lossy(&decoded_data);
+                        self.message_kml = location::Kml::parse(self.context, &d).ok();
+                    }
+                } else if !decoded_data.is_empty() {
+                    self.do_add_single_file_part(
+                        msg_type,
+                        mime_type,
+                        raw_mime.as_ref(),
+                        &decoded_data,
+                        &desired_filename,
+                    );
                 }
             }
             _ => {}
@@ -838,7 +835,7 @@ impl<'a> MimeParser<'a> {
         let mut fld_from: *const mailimf_from = ptr::null();
 
         /* get From: and check there is exactly one sender */
-        let fld = mailimf_find_field(self.header_root, MAILIMF_FIELD_FROM as libc::c_int);
+        let fld = wrapmime::mailimf_find_field(self.header_root, MAILIMF_FIELD_FROM as libc::c_int);
         if !(fld.is_null()
             || {
                 fld_from = (*fld).fld_data.fld_from;
@@ -856,11 +853,9 @@ impl<'a> MimeParser<'a> {
 
             if !mb.is_null() {
                 let from_addr_norm = addr_normalize(as_str((*mb).mb_addr_spec));
-                let recipients = mailimf_get_recipients(self.header_root);
-                if recipients.len() == 1 {
-                    if recipients.contains(from_addr_norm) {
-                        sender_equals_recipient = true;
-                    }
+                let recipients = wrapmime::mailimf_get_recipients(self.header_root);
+                if recipients.len() == 1 && recipients.contains(from_addr_norm) {
+                    sender_equals_recipient = true;
                 }
             }
         }
@@ -887,7 +882,7 @@ impl<'a> MimeParser<'a> {
             unsafe {
                 let fld_message_id = (*field).fld_data.fld_message_id;
                 if !fld_message_id.is_null() {
-                    return Some(to_string((*fld_message_id).mid_value));
+                    return Some(to_string_lossy((*fld_message_id).mid_value));
                 }
             }
         }
@@ -917,22 +912,6 @@ pub struct Part {
     pub param: Params,
 }
 
-pub fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> Option<String> {
-    if mb_list.is_null() {
-        return None;
-    }
-
-    for cur in unsafe { (*(*mb_list).mb_list).into_iter() } {
-        let mb = cur as *mut mailimf_mailbox;
-        if !mb.is_null() && !unsafe { (*mb).mb_addr_spec.is_null() } {
-            let addr = unsafe { as_str((*mb).mb_addr_spec) };
-            return Some(addr_normalize(addr).to_string());
-        }
-    }
-
-    None
-}
-
 unsafe fn hash_header(out: &mut HashMap<String, *mut mailimf_field>, in_0: *const mailimf_fields) {
     if in_0.is_null() {
         return;
@@ -1003,14 +982,12 @@ unsafe fn mailmime_get_mime_type(mime: *mut Mailmime) -> (libc::c_int, Viewtype,
                     ) == 0i32
                     {
                         return (DC_MIMETYPE_TEXT_PLAIN, Viewtype::Text, None);
-                    } else {
-                        if strcmp(
-                            (*c).ct_subtype,
-                            b"html\x00" as *const u8 as *const libc::c_char,
-                        ) == 0i32
-                        {
-                            return (DC_MIMETYPE_TEXT_HTML, Viewtype::Text, None);
-                        }
+                    } else if strcmp(
+                        (*c).ct_subtype,
+                        b"html\x00" as *const u8 as *const libc::c_char,
+                    ) == 0i32
+                    {
+                        return (DC_MIMETYPE_TEXT_HTML, Viewtype::Text, None);
                     }
                 }
 
@@ -1154,214 +1131,6 @@ pub unsafe fn mailmime_find_ct_parameter(
     ptr::null_mut()
 }
 
-pub unsafe fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, Error> {
-    ensure!(!mime.is_null(), "invalid inputs");
-
-    let mut mime_transfer_encoding = MAILMIME_MECHANISM_BINARY as libc::c_int;
-
-    let mime_data = (*mime).mm_data.mm_single;
-    if !(*mime).mm_mime_fields.is_null() {
-        for cur in (*(*(*mime).mm_mime_fields).fld_list).into_iter() {
-            let field = cur as *mut mailmime_field;
-
-            if !field.is_null()
-                && (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int
-                && !(*field).fld_data.fld_encoding.is_null()
-            {
-                mime_transfer_encoding = (*(*field).fld_data.fld_encoding).enc_type;
-                break;
-            }
-        }
-    }
-
-    if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int
-        || mime_transfer_encoding == MAILMIME_MECHANISM_8BIT as libc::c_int
-        || mime_transfer_encoding == MAILMIME_MECHANISM_BINARY as libc::c_int
-    {
-        let decoded_data = (*mime_data).dt_data.dt_text.dt_data;
-        let decoded_data_bytes = (*mime_data).dt_data.dt_text.dt_length;
-
-        if decoded_data.is_null() || decoded_data_bytes <= 0 {
-            bail!("No data to decode found");
-        } else {
-            let result = std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes);
-            return Ok(result.to_vec());
-        }
-    }
-
-    let mut current_index = 0;
-    let mut transfer_decoding_buffer = ptr::null_mut();
-    let mut decoded_data_bytes = 0;
-
-    let r = mailmime_part_parse(
-        (*mime_data).dt_data.dt_text.dt_data,
-        (*mime_data).dt_data.dt_text.dt_length,
-        &mut current_index,
-        mime_transfer_encoding,
-        &mut transfer_decoding_buffer,
-        &mut decoded_data_bytes,
-    );
-
-    if r == MAILIMF_NO_ERROR as libc::c_int
-        && !transfer_decoding_buffer.is_null()
-        && decoded_data_bytes > 0
-    {
-        let result =
-            std::slice::from_raw_parts(transfer_decoding_buffer as *const u8, decoded_data_bytes)
-                .to_vec();
-        mmap_string_unref(transfer_decoding_buffer);
-
-        return Ok(result);
-    }
-
-    Err(format_err!("Failed to to decode"))
-}
-
-pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String> {
-    /* returned addresses are normalized. */
-    let mut recipients: HashSet<String> = Default::default();
-
-    for cur in unsafe { (*(*imffields).fld_list).into_iter() } {
-        let fld = cur as *mut mailimf_field;
-
-        let fld_to: *mut mailimf_to;
-        let fld_cc: *mut mailimf_cc;
-
-        let mut addr_list: *mut mailimf_address_list = ptr::null_mut();
-        if fld.is_null() {
-            continue;
-        }
-
-        let fld = unsafe { *fld };
-
-        // TODO match on enums /rtn
-        match fld.fld_type {
-            13 => {
-                fld_to = unsafe { fld.fld_data.fld_to };
-                if !fld_to.is_null() {
-                    addr_list = unsafe { (*fld_to).to_addr_list };
-                }
-            }
-            14 => {
-                fld_cc = unsafe { fld.fld_data.fld_cc };
-                if !fld_cc.is_null() {
-                    addr_list = unsafe { (*fld_cc).cc_addr_list };
-                }
-            }
-            _ => {}
-        }
-
-        if !addr_list.is_null() {
-            for cur2 in unsafe { &(*(*addr_list).ad_list) } {
-                let adr = cur2 as *mut mailimf_address;
-
-                if adr.is_null() {
-                    continue;
-                }
-                let adr = unsafe { *adr };
-
-                if adr.ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
-                    mailimf_get_recipients_add_addr(&mut recipients, unsafe {
-                        adr.ad_data.ad_mailbox
-                    });
-                } else if adr.ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
-                    let group = unsafe { adr.ad_data.ad_group };
-                    if !group.is_null() && unsafe { !(*group).grp_mb_list.is_null() } {
-                        for cur3 in unsafe { &(*(*(*group).grp_mb_list).mb_list) } {
-                            mailimf_get_recipients_add_addr(
-                                &mut recipients,
-                                cur3 as *mut mailimf_mailbox,
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    recipients
-}
-
-fn mailimf_get_recipients_add_addr(recipients: &mut HashSet<String>, mb: *mut mailimf_mailbox) {
-    if !mb.is_null() {
-        let addr_norm = addr_normalize(as_str(unsafe { (*mb).mb_addr_spec }));
-        recipients.insert(addr_norm.into());
-    }
-}
-
-/*the result is a pointer to mime, must not be freed*/
-pub fn mailimf_find_field(
-    header: *mut mailimf_fields,
-    wanted_fld_type: libc::c_int,
-) -> *mut mailimf_field {
-    if header.is_null() {
-        return ptr::null_mut();
-    }
-
-    let header = unsafe { (*header) };
-    if header.fld_list.is_null() {
-        return ptr::null_mut();
-    }
-
-    for cur in unsafe { &(*header.fld_list) } {
-        let field = cur as *mut mailimf_field;
-        if !field.is_null() {
-            if unsafe { (*field).fld_type } == wanted_fld_type {
-                return field;
-            }
-        }
-    }
-
-    ptr::null_mut()
-}
-
-/*the result is a pointer to mime, must not be freed*/
-pub unsafe fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
-    if mime.is_null() {
-        return ptr::null_mut();
-    }
-
-    match (*mime).mm_type as _ {
-        MAILMIME_MULTIPLE => {
-            for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
-                let header = mailmime_find_mailimf_fields(cur_data as *mut _);
-                if !header.is_null() {
-                    return header;
-                }
-            }
-        }
-        MAILMIME_MESSAGE => return (*mime).mm_data.mm_message.mm_fields,
-        _ => {}
-    }
-
-    ptr::null_mut()
-}
-
-pub unsafe fn mailimf_find_optional_field(
-    header: *mut mailimf_fields,
-    wanted_fld_name: *const libc::c_char,
-) -> *mut mailimf_optional_field {
-    if header.is_null() || (*header).fld_list.is_null() {
-        return ptr::null_mut();
-    }
-    for cur_data in (*(*header).fld_list).into_iter() {
-        let field: *mut mailimf_field = cur_data as *mut _;
-
-        if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let optional_field: *mut mailimf_optional_field = (*field).fld_data.fld_optional_field;
-            if !optional_field.is_null()
-                && !(*optional_field).fld_name.is_null()
-                && !(*optional_field).fld_value.is_null()
-                && strcasecmp((*optional_field).fld_name, wanted_fld_name) == 0i32
-            {
-                return optional_field;
-            }
-        }
-    }
-
-    ptr::null_mut()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1377,14 +1146,13 @@ mod tests {
             let mut mime: *mut Mailmime = ptr::null_mut();
             let mut dummy = 0;
             let res = mailmime_parse(txt, strlen(txt), &mut dummy, &mut mime);
-
             assert_eq!(res, MAIL_NO_ERROR as libc::c_int);
             assert!(!mime.is_null());
 
-            let fields: *mut mailimf_fields = mailmime_find_mailimf_fields(mime);
+            let fields: *mut mailimf_fields = wrapmime::mailmime_find_mailimf_fields(mime);
             assert!(!fields.is_null());
 
-            let mut of_a: *mut mailimf_optional_field = mailimf_find_optional_field(
+            let mut of_a: *mut mailimf_optional_field = wrapmime::mailimf_find_optional_field(
                 fields,
                 b"fielda\x00" as *const u8 as *const libc::c_char,
             );
@@ -1404,7 +1172,7 @@ mod tests {
                 "ValueA",
             );
 
-            of_a = mailimf_find_optional_field(
+            of_a = wrapmime::mailimf_find_optional_field(
                 fields,
                 b"FIELDA\x00" as *const u8 as *const libc::c_char,
             );
@@ -1424,7 +1192,7 @@ mod tests {
                 "ValueA",
             );
 
-            let of_b: *mut mailimf_optional_field = mailimf_find_optional_field(
+            let of_b: *mut mailimf_optional_field = wrapmime::mailimf_find_optional_field(
                 fields,
                 b"FieldB\x00" as *const u8 as *const libc::c_char,
             );
@@ -1447,7 +1215,9 @@ mod tests {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
         let mut mimeparser = MimeParser::new(&context.ctx);
-        unsafe { mimeparser.parse(&raw[..]).unwrap() };
+        unsafe {
+            mimeparser.parse(&raw[..]).unwrap();
+        };
         assert_eq!(mimeparser.subject, None);
         assert_eq!(mimeparser.parts.len(), 1);
     }
@@ -1455,9 +1225,13 @@ mod tests {
     proptest! {
         #[test]
         fn test_dc_mailmime_parse_crash_fuzzy(data in "[!-~\t ]{2000,}") {
+            // this test doesn't exercise much of dc_mimeparser anymore
+            // because a missing From-field early aborts parsing
             let context = dummy_context();
             let mut mimeparser = MimeParser::new(&context.ctx);
-            unsafe { mimeparser.parse(data.as_bytes()).unwrap() };
+            unsafe {
+                assert!(mimeparser.parse(data.as_bytes()).is_err());
+            }
         }
     }
 
@@ -1486,7 +1260,7 @@ mod tests {
     fn test_mimeparser_with_context() {
         unsafe {
             let context = dummy_context();
-            let raw = b"Content-Type: multipart/mixed; boundary=\"==break==\";\nSubject: outer-subject\nX-Special-A: special-a\nFoo: Bar\nChat-Version: 0.0\n\n--==break==\nContent-Type: text/plain; protected-headers=\"v1\";\nSubject: inner-subject\nX-Special-B: special-b\nFoo: Xy\nChat-Version: 1.0\n\ntest1\n\n--==break==--\n\n\x00";
+            let raw = b"From: hello\nContent-Type: multipart/mixed; boundary=\"==break==\";\nSubject: outer-subject\nX-Special-A: special-a\nFoo: Bar\nChat-Version: 0.0\n\n--==break==\nContent-Type: text/plain; protected-headers=\"v1\";\nSubject: inner-subject\nX-Special-B: special-b\nFoo: Xy\nChat-Version: 1.0\n\ntest1\n\n--==break==--\n\n\x00";
             let mut mimeparser = MimeParser::new(&context.ctx);
             mimeparser.parse(&raw[..]).unwrap();
 

src/dc_receive_imf.rs

@@ -1,11 +1,9 @@
-use std::ffi::CString;
 use std::ptr;
 
 use itertools::join;
-use libc::{free, strcmp, strlen};
+use libc::{free, strcmp};
 use mmime::clist::*;
 use mmime::mailimf::types::*;
-use mmime::mailimf::*;
 use mmime::mailmime::content::*;
 use mmime::mailmime::types::*;
 use mmime::mailmime::*;
@@ -13,6 +11,7 @@ use mmime::other::*;
 use sha2::{Digest, Sha256};
 
 use crate::chat::{self, Chat};
+use crate::config::Config;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
@@ -29,6 +28,7 @@ use crate::peerstate::*;
 use crate::securejoin::handle_securejoin_handshake;
 use crate::sql;
 use crate::stock::StockMessage;
+use crate::wrapmime;
 
 #[derive(Debug, PartialEq, Eq)]
 enum CreateEvent {
@@ -81,7 +81,7 @@ pub unsafe fn dc_receive_imf(
     let mut chat_id = 0;
     let mut hidden = 0;
 
-    let mut add_delete_job: libc::c_int = 0;
+    let mut needs_delete_job = false;
     let mut insert_msg_id = 0;
 
     let mut sent_timestamp = 0;
@@ -147,7 +147,7 @@ pub unsafe fn dc_receive_imf(
                 if mime_parser.sender_equals_recipient() {
                     from_id = DC_CONTACT_ID_SELF;
                 }
-            } else if from_list.len() >= 1 {
+            } else if !from_list.is_empty() {
                 // if there is no from given, from_id stays 0 which is just fine. These messages
                 // are very rare, however, we have to add them to the database (they go to the
                 // "deaddrop" chat) to avoid a re-download from the server. See also [**]
@@ -218,7 +218,7 @@ pub unsafe fn dc_receive_imf(
             &mut chat_id,
             &mut to_id,
             flags,
-            &mut add_delete_job,
+            &mut needs_delete_job,
             to_self,
             &mut insert_msg_id,
             &mut created_db_entries,
@@ -249,7 +249,7 @@ pub unsafe fn dc_receive_imf(
             from_id,
             sent_timestamp,
             &mut rr_event_to_send,
-            server_folder,
+            &server_folder,
             server_uid,
         );
     }
@@ -265,7 +265,8 @@ pub unsafe fn dc_receive_imf(
         );
     }
 
-    if 0 != add_delete_job && !created_db_entries.is_empty() {
+    // if we delete we don't need to try moving messages
+    if needs_delete_job && !created_db_entries.is_empty() {
         job_add(
             context,
             Action::DeleteMsgOnImap,
@@ -273,6 +274,8 @@ pub unsafe fn dc_receive_imf(
             Params::new(),
             0,
         );
+    } else {
+        context.do_heuristics_moves(server_folder.as_ref(), insert_msg_id);
     }
 
     info!(
@@ -305,7 +308,7 @@ unsafe fn add_parts(
     chat_id: &mut u32,
     to_id: &mut u32,
     flags: u32,
-    add_delete_job: &mut libc::c_int,
+    needs_delete_job: &mut bool,
     to_self: i32,
     insert_msg_id: &mut u32,
     created_db_entries: &mut Vec<(usize, usize)>,
@@ -370,10 +373,7 @@ unsafe fn add_parts(
     // 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 != SystemMessage::AutocryptSetupMessage && msgrmsg == 0 {
-        let show_emails = context
-            .sql
-            .get_config_int(context, "show_emails")
-            .unwrap_or_default();
+        let show_emails = context.get_config_int(Config::ShowEmails);
         if show_emails == 0 {
             *chat_id = 3;
             allow_creation = 0
@@ -403,7 +403,7 @@ unsafe fn add_parts(
             let handshake = handle_securejoin_handshake(context, mime_parser, *from_id);
             if 0 != handshake & DC_HANDSHAKE_STOP_NORMAL_PROCESSING {
                 *hidden = 1;
-                *add_delete_job = handshake & DC_HANDSHAKE_ADD_DELETE_JOB;
+                *needs_delete_job = 0 != handshake & DC_HANDSHAKE_ADD_DELETE_JOB;
                 state = MessageState::InSeen;
             }
         }
@@ -435,7 +435,7 @@ unsafe fn add_parts(
                 to_ids,
                 chat_id,
                 &mut chat_id_blocked,
-            );
+            )?;
             if 0 != *chat_id && Blocked::Not != chat_id_blocked && create_blocked == Blocked::Not {
                 chat::unblock(context, *chat_id);
                 chat_id_blocked = Blocked::Not;
@@ -494,10 +494,12 @@ unsafe fn add_parts(
         // if the chat_id is blocked,
         // for unknown senders and non-delta messages set the state to NOTICED
         // to not result in a contact request (this would require the state FRESH)
-        if Blocked::Not != chat_id_blocked && state == MessageState::InFresh {
-            if !incoming_origin.is_verified() && msgrmsg == 0 {
-                state = MessageState::InNoticed;
-            }
+        if Blocked::Not != chat_id_blocked
+            && state == MessageState::InFresh
+            && !incoming_origin.is_verified()
+            && msgrmsg == 0
+        {
+            state = MessageState::InNoticed;
         }
     } else {
         // Outgoing
@@ -518,7 +520,7 @@ unsafe fn add_parts(
                     to_ids,
                     chat_id,
                     &mut chat_id_blocked,
-                );
+                )?;
                 if 0 != *chat_id && Blocked::Not != chat_id_blocked {
                     chat::unblock(context, *chat_id);
                     chat_id_blocked = Blocked::Not;
@@ -578,11 +580,11 @@ unsafe fn add_parts(
     );
 
     // unarchive chat
-    chat::unarchive(context, *chat_id).unwrap();
+    chat::unarchive(context, *chat_id)?;
 
     // 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_bool(context, "save_mime_headers");
+    let save_mime_headers = context.get_config_bool(Config::SaveMimeHeaders);
     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() {
@@ -626,7 +628,7 @@ unsafe fn add_parts(
                     }
 
                     if let Some(ref msg) = part.msg {
-                        if !mime_parser.location_kml.is_none()
+                        if mime_parser.location_kml.is_some()
                             && icnt == 1
                             && (msg == "-location-" || msg.is_empty())
                         {
@@ -685,8 +687,8 @@ unsafe fn add_parts(
                         } else {
                             None
                         },
-                        to_string(mime_in_reply_to),
-                        to_string(mime_references),
+                        to_string_lossy(mime_in_reply_to),
+                        to_string_lossy(mime_references),
                     ])?;
 
                     txt_raw = None;
@@ -720,7 +722,6 @@ unsafe fn add_parts(
         }
     }
 
-    context.do_heuristics_moves(server_folder.as_ref(), *insert_msg_id);
     cleanup(mime_in_reply_to, mime_references);
 
     Ok(())
@@ -736,10 +737,7 @@ unsafe fn handle_reports(
     server_folder: impl AsRef<str>,
     server_uid: u32,
 ) {
-    let mdns_enabled = context
-        .sql
-        .get_config_int(context, "mdns_enabled")
-        .unwrap_or_else(|| DC_MDNS_DEFAULT_ENABLED);
+    let mdns_enabled = context.get_config_bool(Config::MdnsEnabled);
 
     for report_root in &mime_parser.reports {
         let report_root = *report_root;
@@ -758,7 +756,7 @@ unsafe fn handle_reports(
             && (*(*report_root).mm_data.mm_multipart.mm_mp_list).count >= 2
         {
             // to get a clear functionality, do not show incoming MDNs if the options is disabled
-            if 0 != mdns_enabled {
+            if mdns_enabled {
                 let report_data = (if !if !(*(*report_root).mm_data.mm_multipart.mm_mp_list)
                     .first
                     .is_null()
@@ -795,7 +793,7 @@ unsafe fn handle_reports(
                         b"disposition-notification\x00" as *const u8 as *const libc::c_char,
                     ) == 0
                 {
-                    if let Ok(report_body) = mailmime_transfer_decode(report_data) {
+                    if let Ok(report_body) = wrapmime::mailmime_transfer_decode(report_data) {
                         let mut report_parsed = std::ptr::null_mut();
                         let mut dummy = 0;
 
@@ -807,13 +805,14 @@ unsafe fn handle_reports(
                         ) == MAIL_NO_ERROR as libc::c_int
                             && !report_parsed.is_null()
                         {
-                            let report_fields = mailmime_find_mailimf_fields(report_parsed);
+                            let report_fields =
+                                wrapmime::mailmime_find_mailimf_fields(report_parsed);
                             if !report_fields.is_null() {
-                                let of_disposition = mailimf_find_optional_field(
+                                let of_disposition = wrapmime::mailimf_find_optional_field(
                                     report_fields,
                                     b"Disposition\x00" as *const u8 as *const libc::c_char,
                                 );
-                                let of_org_msgid = mailimf_find_optional_field(
+                                let of_org_msgid = wrapmime::mailimf_find_optional_field(
                                     report_fields,
                                     b"Original-Message-ID\x00" as *const u8 as *const libc::c_char,
                                 );
@@ -822,24 +821,16 @@ unsafe fn handle_reports(
                                     && !of_org_msgid.is_null()
                                     && !(*of_org_msgid).fld_value.is_null()
                                 {
-                                    let mut rfc724_mid_0 = std::ptr::null_mut();
-                                    dummy = 0;
-
-                                    if mailimf_msg_id_parse(
+                                    if let Ok(rfc724_mid) = wrapmime::parse_message_id(as_str(
                                         (*of_org_msgid).fld_value,
-                                        strlen((*of_org_msgid).fld_value),
-                                        &mut dummy,
-                                        &mut rfc724_mid_0,
-                                    ) == MAIL_NO_ERROR as libc::c_int
-                                        && !rfc724_mid_0.is_null()
-                                    {
+                                    )) {
                                         let mut chat_id_0 = 0;
                                         let mut msg_id = 0;
 
                                         if message::mdn_from_ext(
                                             context,
                                             from_id,
-                                            as_str(rfc724_mid_0),
+                                            &rfc724_mid,
                                             sent_timestamp,
                                             &mut chat_id_0,
                                             &mut msg_id,
@@ -847,7 +838,6 @@ unsafe fn handle_reports(
                                             rr_event_to_send.push((chat_id_0, msg_id));
                                         }
                                         mdn_consumed = (msg_id != 0) as libc::c_int;
-                                        free(rfc724_mid_0.cast());
                                     }
                                 }
                             }
@@ -861,12 +851,7 @@ unsafe fn handle_reports(
                 let mut param = Params::new();
                 param.set(Param::ServerFolder, server_folder.as_ref());
                 param.set_int(Param::ServerUid, server_uid as i32);
-                if mime_parser.is_send_by_messenger
-                    && 0 != context
-                        .sql
-                        .get_config_int(context, "mvbox_move")
-                        .unwrap_or_else(|| 1)
-                {
+                if mime_parser.is_send_by_messenger && context.get_config_bool(Config::MvboxMove) {
                     param.set_int(Param::AlsoMove, 1);
                 }
                 job_add(context, Action::MarkseenMdnOnImap, 0, param, 0);
@@ -982,7 +967,7 @@ unsafe fn create_or_lookup_group(
     to_ids: &mut Vec<u32>,
     ret_chat_id: *mut u32,
     ret_chat_id_blocked: &mut Blocked,
-) {
+) -> Result<()> {
     let group_explicitly_left: bool;
     let mut chat_id = 0;
     let mut chat_id_blocked = Blocked::Not;
@@ -1040,7 +1025,7 @@ unsafe fn create_or_lookup_group(
             {
                 let fld_in_reply_to = (*field).fld_data.fld_in_reply_to;
                 if !fld_in_reply_to.is_null() {
-                    grpid = to_string(dc_extract_grpid_from_rfc724_mid_list(
+                    grpid = to_string_lossy(dc_extract_grpid_from_rfc724_mid_list(
                         (*fld_in_reply_to).mid_list,
                     ));
                 }
@@ -1051,7 +1036,7 @@ unsafe fn create_or_lookup_group(
                 {
                     let fld_references = (*field).fld_data.fld_references;
                     if !fld_references.is_null() {
-                        grpid = to_string(dc_extract_grpid_from_rfc724_mid_list(
+                        grpid = to_string_lossy(dc_extract_grpid_from_rfc724_mid_list(
                             (*fld_references).mid_list,
                         ));
                     }
@@ -1067,16 +1052,16 @@ unsafe fn create_or_lookup_group(
                         to_ids,
                         &mut chat_id,
                         &mut chat_id_blocked,
-                    );
+                    )?;
                     cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-                    return;
+                    return Ok(());
                 }
             }
         }
     }
 
     if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Name") {
-        grpname = Some(dc_decode_header_words_safe(&optional_field));
+        grpname = Some(dc_decode_header_words(&optional_field));
     }
     if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Member-Removed") {
         X_MrRemoveFromGrp = Some(optional_field);
@@ -1168,8 +1153,7 @@ unsafe fn create_or_lookup_group(
     group_explicitly_left = chat::is_group_explicitly_left(context, &grpid).unwrap_or_default();
 
     let self_addr = context
-        .sql
-        .get_config(context, "configured_addr")
+        .get_config(Config::ConfiguredAddr)
         .unwrap_or_default();
     if chat_id == 0
             && !mime_parser.is_mailinglist_message()
@@ -1195,7 +1179,7 @@ unsafe fn create_or_lookup_group(
         }
         if 0 == allow_creation {
             cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-            return;
+            return Ok(());
         }
         chat_id = create_group_record(
             context,
@@ -1223,10 +1207,10 @@ unsafe fn create_or_lookup_group(
                 to_ids,
                 &mut chat_id,
                 &mut chat_id_blocked,
-            );
+            )?;
         }
         cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return;
+        return Ok(());
     }
 
     // execute group commands
@@ -1279,7 +1263,7 @@ unsafe fn create_or_lookup_group(
                 } else {
                     chat.param.set(Param::ProfileImage, grpimage);
                 }
-                chat.update_param(context).unwrap();
+                chat.update_param(context)?;
                 send_EVENT_CHAT_MODIFIED = 1;
             }
         }
@@ -1343,11 +1327,12 @@ unsafe fn create_or_lookup_group(
                 to_ids,
                 &mut chat_id,
                 &mut chat_id_blocked,
-            );
+            )?;
         }
     }
 
     cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
+    return Ok(());
 }
 
 /// Handle groups for received messages
@@ -1360,7 +1345,7 @@ unsafe fn create_or_lookup_adhoc_group(
     to_ids: &mut Vec<u32>,
     ret_chat_id: *mut u32,
     ret_chat_id_blocked: &mut Blocked,
-) {
+) -> Result<()> {
     // if we're here, no grpid was found, check there is an existing ad-hoc
     // group matching the to-list or if we can create one
     let mut chat_id = 0;
@@ -1380,7 +1365,7 @@ unsafe fn create_or_lookup_adhoc_group(
     if to_ids.is_empty() || mime_parser.is_mailinglist_message() {
         // too few contacts or a mailinglist
         cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return;
+        return Ok(());
     }
 
     let mut member_ids = to_ids.clone();
@@ -1393,10 +1378,10 @@ unsafe fn create_or_lookup_adhoc_group(
     if member_ids.len() < 3 {
         // too few contacts given
         cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return;
+        return Ok(());
     }
 
-    let chat_ids = search_chat_ids_by_contact_ids(context, &member_ids);
+    let chat_ids = search_chat_ids_by_contact_ids(context, &member_ids)?;
     if !chat_ids.is_empty() {
         let chat_ids_str = join(chat_ids.iter().map(|x| x.to_string()), ",");
         let res = context.sql.query_row(
@@ -1416,13 +1401,13 @@ unsafe fn create_or_lookup_adhoc_group(
             chat_id_blocked = id_blocked;
             /* success, chat found */
             cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-            return;
+            return Ok(());
         }
     }
 
     if 0 == allow_creation {
         cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return;
+        return Ok(());
     }
     // we do not check if the message is a reply to another group, this may result in
     // chats with unclear member list. instead we create a new group in the following lines ...
@@ -1432,7 +1417,7 @@ unsafe fn create_or_lookup_adhoc_group(
     let grpid = create_adhoc_grp_id(context, &member_ids);
     if grpid.is_empty() {
         cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
-        return;
+        return Ok(());
     }
 
     // use subject as initial chat name
@@ -1458,6 +1443,7 @@ unsafe fn create_or_lookup_adhoc_group(
     context.call_cb(Event::ChatModified(chat_id));
 
     cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
+    return Ok(());
 }
 
 fn create_group_record(
@@ -1490,7 +1476,7 @@ fn create_group_record(
     sql::get_rowid(context, &context.sql, "chats", "grpid", grpid.as_ref())
 }
 
-fn create_adhoc_grp_id(context: &Context, member_ids: &Vec<u32>) -> String {
+fn create_adhoc_grp_id(context: &Context, member_ids: &[u32]) -> String {
     /* algorithm:
     - sort normalized, lowercased, e-mail addresses alphabetically
     - put all e-mail addresses into a single string, separate the address by a single comma
@@ -1499,8 +1485,7 @@ fn create_adhoc_grp_id(context: &Context, member_ids: &Vec<u32>) -> String {
      */
     let member_ids_str = join(member_ids.iter().map(|x| x.to_string()), ",");
     let member_cs = context
-        .sql
-        .get_config(context, "configured_addr")
+        .get_config(Config::ConfiguredAddr)
         .unwrap_or_else(|| "no-self".to_string())
         .to_lowercase();
 
@@ -1536,7 +1521,10 @@ fn hex_hash(s: impl AsRef<str>) -> String {
 }
 
 #[allow(non_snake_case)]
-fn search_chat_ids_by_contact_ids(context: &Context, unsorted_contact_ids: &Vec<u32>) -> Vec<u32> {
+fn search_chat_ids_by_contact_ids(
+    context: &Context,
+    unsorted_contact_ids: &Vec<u32>,
+) -> Result<Vec<u32>> {
     /* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
     let mut contact_ids = Vec::with_capacity(23);
     let mut chat_ids = Vec::with_capacity(23);
@@ -1591,18 +1579,18 @@ fn search_chat_ids_by_contact_ids(context: &Context, unsorted_contact_ids: &Vec<
                     }
                 Ok(())
                 }
-            ).unwrap(); // TODO: better error handling
+            )?;
         }
     }
 
-    chat_ids
+    Ok(chat_ids)
 }
 
 fn check_verified_properties(
     context: &Context,
     mimeparser: &MimeParser,
     from_id: u32,
-    to_ids: &Vec<u32>,
+    to_ids: &[u32],
 ) -> Result<()> {
     let contact = Contact::load_from_db(context, from_id)?;
 
@@ -1670,7 +1658,7 @@ fn check_verified_properties(
                 let fp = peerstate.gossip_key_fingerprint.clone();
                 if let Some(fp) = fp {
                     peerstate.set_verified(0, &fp, 2);
-                    peerstate.save_to_db(&context.sql, false).unwrap();
+                    peerstate.save_to_db(&context.sql, false)?;
                     is_verified = true;
                 }
             }
@@ -1697,13 +1685,7 @@ fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {
 
 unsafe fn dc_is_reply_to_known_message(context: &Context, mime_parser: &MimeParser) -> libc::c_int {
     /* check if the message is a reply to a known message; the replies are identified by the Message-ID from
-    `In-Reply-To`/`References:` (to support non-Delta-Clients) or from `Chat-Predecessor:` (Delta clients, see comment in dc_chat.c) */
-    if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Predecessor") {
-        let optional_field_c = CString::new(optional_field).unwrap();
-        if 0 != is_known_rfc724_mid(context, optional_field_c.as_ptr()) {
-            return 1;
-        }
-    }
+    `In-Reply-To`/`References:` (to support non-Delta-Clients) */
 
     if let Some(field) = mime_parser.lookup_field("In-Reply-To") {
         if (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
@@ -1722,13 +1704,13 @@ unsafe fn dc_is_reply_to_known_message(context: &Context, mime_parser: &MimePars
     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(
+            if !fld_references.is_null()
+                && is_known_rfc724_mid_in_list(
                     context,
                     (*(*field).fld_data.fld_references).mid_list,
-                ) {
-                    return 1;
-                }
+                )
+            {
+                return 1;
             }
         }
     }
@@ -1742,12 +1724,12 @@ unsafe fn is_known_rfc724_mid_in_list(context: &Context, mid_list: *const clist)
     }
 
     for data in &*mid_list {
-        if 0 != is_known_rfc724_mid(context, data.cast()) {
+        if is_known_rfc724_mid(context, data.cast()) != 0 {
             return true;
         }
     }
 
-    return false;
+    false
 }
 
 /// Check if a message is a reply to a known message (messenger or non-messenger).
@@ -1951,8 +1933,7 @@ unsafe fn add_or_lookup_contact_by_addr(
     }
     *check_self = 0;
     let self_addr = context
-        .sql
-        .get_config(context, "configured_addr")
+        .get_config(Config::ConfiguredAddr)
         .unwrap_or_default();
 
     if addr_cmp(self_addr, as_str(addr_spec)) {
@@ -1965,17 +1946,15 @@ unsafe fn add_or_lookup_contact_by_addr(
     /* add addr_spec if missing, update otherwise */
     let mut display_name_dec = "".to_string();
     if !display_name_enc.is_null() {
-        let tmp = as_str(dc_decode_header_words(display_name_enc));
+        let tmp = dc_decode_header_words(as_str(display_name_enc));
         display_name_dec = normalize_name(&tmp);
     }
     /*can be NULL*/
     let row_id = Contact::add_or_lookup(context, display_name_dec, as_str(addr_spec), origin)
         .map(|(id, _)| id)
         .unwrap_or_default();
-    if 0 != row_id {
-        if !ids.contains(&row_id) {
-            ids.push(row_id);
-        }
+    if 0 != row_id && !ids.contains(&row_id) {
+        ids.push(row_id);
     };
 }
 

src/dc_simplify.rs

@@ -10,18 +10,16 @@ pub struct Simplify {
 ///
 /// Also return whether not-standard (rfc3676, §4.3) footer is found.
 fn find_message_footer(lines: &[&str]) -> (usize, bool) {
-    for ix in 0..lines.len() {
-        let line = lines[ix];
-
+    for (ix, &line) in lines.iter().enumerate() {
         // quoted-printable may encode `-- ` to `-- =20` which is converted
         // back to `--  `
-        match line.as_ref() {
+        match line {
             "-- " | "--  " => return (ix, false),
             "--" | "---" | "----" => return (ix, true),
             _ => (),
         }
     }
-    return (lines.len(), false);
+    (lines.len(), false)
 }
 
 impl Simplify {
@@ -103,10 +101,8 @@ impl Simplify {
             if let Some(last_quoted_line) = l_lastQuotedLine {
                 l_last = last_quoted_line;
                 is_cut_at_end = true;
-                if l_last > 1 {
-                    if is_empty_line(lines[l_last - 1]) {
-                        l_last -= 1
-                    }
+                if l_last > 1 && is_empty_line(lines[l_last - 1]) {
+                    l_last -= 1
                 }
                 if l_last > 1 {
                     let line = lines[l_last - 1];
@@ -205,7 +201,7 @@ fn is_quoted_headline(buf: &str) -> bool {
 }
 
 fn is_plain_quote(buf: &str) -> bool {
-    buf.starts_with(">")
+    buf.starts_with('>')
 }
 
 #[cfg(test)]

src/dc_strencode.rs

@@ -4,7 +4,7 @@ use std::ffi::CString;
 use std::ptr;
 
 use charset::Charset;
-use libc::{free, strlen};
+use libc::free;
 use mmime::mailmime::decode::mailmime_encoded_phrase_parse;
 use mmime::other::*;
 use percent_encoding::{percent_decode, utf8_percent_encode, AsciiSet, CONTROLS};
@@ -68,28 +68,7 @@ fn quote_word(word: &[u8]) -> String {
  * Encode/decode header words, RFC 2047
  ******************************************************************************/
 
-pub unsafe fn dc_decode_header_words(in_0: *const libc::c_char) -> *mut libc::c_char {
-    if in_0.is_null() {
-        return ptr::null_mut();
-    }
-    let mut out: *mut libc::c_char = ptr::null_mut();
-    let mut cur_token = 0;
-    let r: libc::c_int = mailmime_encoded_phrase_parse(
-        b"iso-8859-1\x00" as *const u8 as *const libc::c_char,
-        in_0,
-        strlen(in_0),
-        &mut cur_token,
-        b"utf-8\x00" as *const u8 as *const libc::c_char,
-        &mut out,
-    );
-    if r != MAILIMF_NO_ERROR as libc::c_int || out.is_null() {
-        out = dc_strdup(in_0)
-    }
-
-    out
-}
-
-pub fn dc_decode_header_words_safe(input: &str) -> String {
+pub(crate) fn dc_decode_header_words(input: &str) -> String {
     static FROM_ENCODING: &[u8] = b"iso-8859-1\x00";
     static TO_ENCODING: &[u8] = b"utf-8\x00";
     let mut out = ptr::null_mut();
@@ -107,7 +86,7 @@ pub fn dc_decode_header_words_safe(input: &str) -> String {
         if r as u32 != MAILIMF_NO_ERROR || out.is_null() {
             input.to_string()
         } else {
-            let res = to_string(out);
+            let res = to_string_lossy(out);
             free(out.cast());
             res
         }
@@ -177,60 +156,31 @@ pub fn dc_decode_ext_header(to_decode: &[u8]) -> Cow<str> {
 mod tests {
     use super::*;
 
-    use libc::strcmp;
-    use std::ffi::CStr;
-
     #[test]
     fn test_dc_decode_header_words() {
-        unsafe {
-            let mut buf1: *mut libc::c_char = dc_decode_header_words(
-                b"=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?=\x00" as *const u8 as *const libc::c_char,
-            );
-            assert_eq!(
-                strcmp(
-                    buf1,
-                    b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\x00" as *const u8 as *const libc::c_char
-                ),
-                0
-            );
-            free(buf1 as *mut libc::c_void);
+        assert_eq!(
+            dc_decode_header_words("=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?="),
+            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
+        );
 
-            buf1 =
-                dc_decode_header_words(b"just ascii test\x00" as *const u8 as *const libc::c_char);
-            assert_eq!(CStr::from_ptr(buf1).to_str().unwrap(), "just ascii test");
-            free(buf1 as *mut libc::c_void);
+        assert_eq!(dc_decode_header_words("just ascii test"), "just ascii test");
 
-            assert_eq!(dc_encode_header_words("abcdef"), "abcdef");
+        assert_eq!(dc_encode_header_words("abcdef"), "abcdef");
 
-            let r = dc_encode_header_words(
-                std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec())
-                    .unwrap(),
+        let r = dc_encode_header_words(
+            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
+        );
+        assert!(r.starts_with("=?utf-8"));
+
+        assert_eq!(
+            dc_decode_header_words(&r),
+            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
+        );
+
+        assert_eq!(
+                dc_decode_header_words("=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?="),
+                std::string::String::from_utf8(b"attachment;\r\n filename=\"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\";\r\n size=39".to_vec()).unwrap(),
             );
-            assert!(r.starts_with("=?utf-8"));
-
-            buf1 = r.strdup();
-            let buf2: *mut libc::c_char = dc_decode_header_words(buf1);
-            assert_eq!(
-                strcmp(
-                    buf2,
-                    b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\x00" as *const u8 as *const libc::c_char
-                ),
-                0
-            );
-            free(buf2 as *mut libc::c_void);
-
-            buf1 = dc_decode_header_words(
-                b"=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?=\x00" as *const u8 as *const libc::c_char
-            );
-            assert_eq!(
-                strcmp(
-                    buf1,
-                    b"attachment;\r\n filename=\"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\";\r\n size=39\x00" as *const u8 as *const libc::c_char,
-
-                ),
-                0
-            );
-        }
     }
 
     #[test]
@@ -293,7 +243,7 @@ mod tests {
         #[test]
         fn test_dc_header_roundtrip(input: String) {
             let encoded = dc_encode_header_words(&input);
-            let decoded = dc_decode_header_words_safe(&encoded);
+            let decoded = dc_decode_header_words(&encoded);
 
             assert_eq!(input, decoded);
         }

src/dc_tools.rs

@@ -17,6 +17,7 @@ use rand::{thread_rng, Rng};
 
 use crate::context::Context;
 use crate::error::Error;
+use crate::events::Event;
 
 pub(crate) fn dc_exactly_one_bit_set(v: libc::c_int) -> bool {
     0 != v && 0 == v & (v - 1)
@@ -29,11 +30,11 @@ pub(crate) fn dc_exactly_one_bit_set(v: libc::c_int) -> bool {
 /// # Examples
 ///
 /// ```
-/// use deltachat::dc_tools::{dc_strdup, to_string};
+/// use deltachat::dc_tools::{dc_strdup, to_string_lossy};
 /// unsafe {
 ///     let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
 ///     let str_a_copy = dc_strdup(str_a);
-///     assert_eq!(to_string(str_a_copy), "foobar");
+///     assert_eq!(to_string_lossy(str_a_copy), "foobar");
 ///     assert_ne!(str_a, str_a_copy);
 /// }
 /// ```
@@ -50,14 +51,6 @@ pub unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
     ret
 }
 
-pub(crate) fn dc_atoi_null_is_0(s: *const libc::c_char) -> libc::c_int {
-    if !s.is_null() {
-        as_str(s).parse().unwrap_or_default()
-    } else {
-        0
-    }
-}
-
 unsafe fn dc_ltrim(buf: *mut libc::c_char) {
     let mut len: libc::size_t;
     let mut cur: *const libc::c_uchar;
@@ -141,7 +134,7 @@ pub(crate) fn dc_truncate(buf: &str, approx_chars: usize, do_unwrap: bool) -> Co
             .unwrap_or_default();
 
         if let Some(index) = buf[..end_pos].rfind(|c| c == ' ' || c == '\n') {
-            Cow::Owned(format!("{}{}", &buf[..index + 1], ellipse))
+            Cow::Owned(format!("{}{}", &buf[..=index], ellipse))
         } else {
             Cow::Owned(format!("{}{}", &buf[..end_pos], ellipse))
         }
@@ -334,14 +327,14 @@ fn encode_66bits_as_base64(v1: u32, v2: u32, fill: u32) -> String {
         enc.write_u8(((fill & 0x3) as u8) << 6).unwrap();
         enc.finish().unwrap();
     }
-    assert_eq!(wrapped_writer.pop(), Some('A' as u8)); // Remove last "A"
+    assert_eq!(wrapped_writer.pop(), Some(b'A')); // Remove last "A"
     String::from_utf8(wrapped_writer).unwrap()
 }
 
 pub(crate) fn dc_create_incoming_rfc724_mid(
     message_timestamp: i64,
     contact_id_from: u32,
-    contact_ids_to: &Vec<u32>,
+    contact_ids_to: &[u32],
 ) -> Option<String> {
     if contact_ids_to.is_empty() {
         return None;
@@ -423,10 +416,10 @@ fn get_safe_basename(filename: &str) -> String {
     // this might be a path that comes in from another operating system
     let mut index: usize = 0;
 
-    if let Some(unix_index) = filename.rfind("/") {
+    if let Some(unix_index) = filename.rfind('/') {
         index = unix_index + 1;
     }
-    if let Some(win_index) = filename.rfind("\\") {
+    if let Some(win_index) = filename.rfind('\\') {
         index = max(index, win_index + 1);
     }
     if index >= filename.len() {
@@ -439,7 +432,7 @@ fn get_safe_basename(filename: &str) -> String {
 
 pub fn dc_derive_safe_stem_ext(filename: &str) -> (String, String) {
     let basename = get_safe_basename(&filename);
-    let (mut stem, mut ext) = if let Some(index) = basename.rfind(".") {
+    let (mut stem, mut ext) = if let Some(index) = basename.rfind('.') {
         (
             basename[0..index].to_string(),
             basename[index..].to_string(),
@@ -512,10 +505,14 @@ pub(crate) fn dc_delete_file(context: &Context, path: impl AsRef<std::path::Path
         return false;
     }
 
+    let dpath = format!("{}", path.as_ref().to_string_lossy());
     match fs::remove_file(path_abs) {
-        Ok(_) => true,
+        Ok(_) => {
+            context.call_cb(Event::DeletedBlobFile(dpath));
+            true
+        }
         Err(_err) => {
-            warn!(context, "Cannot delete \"{}\".", path.as_ref().display());
+            warn!(context, "Cannot delete \"{}\".", dpath);
             false
         }
     }
@@ -632,7 +629,10 @@ fn dc_make_rel_path(context: &Context, path: &mut String) {
         .map(|s| path.starts_with(s))
         .unwrap_or_default()
     {
-        *path = path.replace(context.get_blobdir().to_str().unwrap(), "$BLOBDIR");
+        *path = path.replace(
+            context.get_blobdir().to_str().unwrap_or_default(),
+            "$BLOBDIR",
+        );
     }
 }
 
@@ -793,22 +793,6 @@ impl<T: AsRef<str>> StrExt for T {
     }
 }
 
-pub fn to_string(s: *const libc::c_char) -> String {
-    if s.is_null() {
-        return "".into();
-    }
-
-    let cstr = unsafe { CStr::from_ptr(s) };
-
-    cstr.to_str().map(|s| s.to_string()).unwrap_or_else(|err| {
-        panic!(
-            "Non utf8 string: '{:?}' ({:?})",
-            cstr.to_string_lossy(),
-            err
-        );
-    })
-}
-
 pub fn to_string_lossy(s: *const libc::c_char) -> String {
     if s.is_null() {
         return "".into();
@@ -1347,6 +1331,25 @@ mod tests {
         assert_eq!(grpid, Some("1234567890123456"));
     }
 
+    #[test]
+    fn test_dc_create_outgoing_rfc724_mid() {
+        // create a normal message-id
+        let mid = dc_create_outgoing_rfc724_mid(None, "foo@bar.de");
+        assert!(mid.starts_with("Mr."));
+        assert!(mid.ends_with("bar.de"));
+        assert!(dc_extract_grpid_from_rfc724_mid(mid.as_str()).is_none());
+
+        // create a message-id containing a group-id
+        let grpid = dc_create_id();
+        let mid = dc_create_outgoing_rfc724_mid(Some(&grpid), "foo@bar.de");
+        assert!(mid.starts_with("Gr."));
+        assert!(mid.ends_with("bar.de"));
+        assert_eq!(
+            dc_extract_grpid_from_rfc724_mid(mid.as_str()),
+            Some(grpid.as_str())
+        );
+    }
+
     #[test]
     fn test_emailaddress_parse() {
         assert_eq!(EmailAddress::new("").is_ok(), false);
@@ -1431,8 +1434,8 @@ mod tests {
         unsafe {
             let res = strndup(b"helloworld\x00" as *const u8 as *const libc::c_char, 4);
             assert_eq!(
-                to_string(res),
-                to_string(b"hell\x00" as *const u8 as *const libc::c_char)
+                to_string_lossy(res),
+                to_string_lossy(b"hell\x00" as *const u8 as *const libc::c_char)
             );
             assert_eq!(strlen(res), 4);
             free(res as *mut _);
@@ -1526,12 +1529,12 @@ mod tests {
         unsafe {
             let input = "foo\r\nbar".strdup();
             dc_remove_cr_chars(input);
-            assert_eq!("foo\nbar", to_string(input));
+            assert_eq!("foo\nbar", to_string_lossy(input));
             free(input.cast());
 
             let input = "\rfoo\r\rbar\r".strdup();
             dc_remove_cr_chars(input);
-            assert_eq!("foobar", to_string(input));
+            assert_eq!("foobar", to_string_lossy(input));
             free(input.cast());
         }
     }

src/e2ee.rs

@@ -22,7 +22,6 @@ use num_traits::FromPrimitive;
 use crate::aheader::*;
 use crate::config::Config;
 use crate::context::Context;
-use crate::dc_mimeparser::*;
 use crate::dc_tools::*;
 use crate::error::*;
 use crate::key::*;
@@ -47,12 +46,9 @@ pub struct EncryptHelper {
 
 impl EncryptHelper {
     pub fn new(context: &Context) -> Result<EncryptHelper> {
-        let prefer_encrypt = context
-            .sql
-            .get_config_int(&context, "e2ee_enabled")
-            .and_then(EncryptPreference::from_i32)
-            .unwrap_or_default();
-
+        let prefer_encrypt =
+            EncryptPreference::from_i32(context.get_config_int(Config::E2eeEnabled))
+                .unwrap_or_default();
         let addr = match context.get_config(Config::ConfiguredAddr) {
             None => {
                 bail!("addr not configured!");
@@ -266,103 +262,80 @@ pub fn try_decrypt(
     context: &Context,
     in_out_message: *mut Mailmime,
 ) -> Result<(bool, HashSet<String>, HashSet<String>)> {
+    // just a pointer into mailmime structure, must not be freed
+    let imffields = wrapmime::mailmime_find_mailimf_fields(in_out_message);
+    ensure!(
+        !in_out_message.is_null() && !imffields.is_null(),
+        "corrupt invalid mime inputs"
+    );
+
+    let from = wrapmime::get_field_from(imffields)?;
+    let message_time = wrapmime::get_field_date(imffields)?;
+
+    let mut peerstate = None;
+    let autocryptheader = Aheader::from_imffields(&from, imffields);
+
+    if message_time > 0 {
+        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)?;
+            }
+        } else if let Some(ref header) = autocryptheader {
+            let p = Peerstate::from_header(context, header, message_time);
+            p.save_to_db(&context.sql, true)?;
+            peerstate = Some(p);
+        }
+    }
+    /* possibly perform decryption */
+    let mut private_keyring = Keyring::default();
+    let mut public_keyring_for_validate = Keyring::default();
     let mut encrypted = false;
     let mut signatures = HashSet::default();
     let mut gossipped_addr = HashSet::default();
 
-    // just a pointer into mailmime structure, must not be freed
-    let imffields = unsafe { mailmime_find_mailimf_fields(in_out_message) };
-    let mut message_time = 0;
-    let mut from = None;
-    let mut private_keyring = Keyring::default();
-    let mut public_keyring_for_validate = Keyring::default();
-    let mut gossip_headers = ptr::null_mut();
+    let self_addr = context.get_config(Config::ConfiguredAddr);
 
-    // XXX do wrapmime:: helper for the next block
-    if !(in_out_message.is_null() || imffields.is_null()) {
-        let mut field = mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
-
-        if !field.is_null() && unsafe { !(*field).fld_data.fld_from.is_null() } {
-            let mb_list = unsafe { (*(*field).fld_data.fld_from).frm_mb_list };
-            from = mailimf_find_first_addr(mb_list);
-        }
-
-        field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
-        if !field.is_null() && unsafe { !(*field).fld_data.fld_orig_date.is_null() } {
-            let orig_date = unsafe { (*field).fld_data.fld_orig_date };
-
-            if !orig_date.is_null() {
-                let dt = unsafe { (*orig_date).dt_date_time };
-                message_time = dc_timestamp_from_date(dt);
-                if message_time != 0 && message_time > time() {
-                    message_time = time()
+    if let Some(self_addr) = self_addr {
+        if private_keyring.load_self_private_for_decrypting(context, self_addr, &context.sql) {
+            if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 {
+                peerstate = Peerstate::from_addr(&context, &context.sql, &from);
+            }
+            if let Some(ref peerstate) = peerstate {
+                if peerstate.degrade_event.is_some() {
+                    handle_degrade_event(context, &peerstate)?;
+                }
+                if let Some(ref key) = peerstate.gossip_key {
+                    public_keyring_for_validate.add_ref(key);
+                }
+                if let Some(ref key) = peerstate.public_key {
+                    public_keyring_for_validate.add_ref(key);
                 }
             }
-        }
-        let mut peerstate = None;
-        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).unwrap();
-                    } 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).unwrap();
-                    }
-                } else if let Some(ref header) = autocryptheader {
-                    let p = Peerstate::from_header(context, header, message_time);
-                    p.save_to_db(&context.sql, true).unwrap();
-                    peerstate = Some(p);
-                }
-            }
-        }
-        /* load private key for decryption */
-        let self_addr = context.get_config(Config::ConfiguredAddr);
-        if let Some(self_addr) = self_addr {
-            if private_keyring.load_self_private_for_decrypting(context, self_addr, &context.sql) {
-                if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 {
-                    peerstate =
-                        Peerstate::from_addr(&context, &context.sql, &from.unwrap_or_default());
-                }
-                if let Some(ref peerstate) = peerstate {
-                    if peerstate.degrade_event.is_some() {
-                        handle_degrade_event(context, &peerstate)?;
-                    }
-                    if let Some(ref key) = peerstate.gossip_key {
-                        public_keyring_for_validate.add_ref(key);
-                    }
-                    if let Some(ref key) = peerstate.public_key {
-                        public_keyring_for_validate.add_ref(key);
-                    }
-                }
-
-                encrypted = decrypt_if_autocrypt_message(
-                    context,
-                    in_out_message,
-                    &private_keyring,
-                    &public_keyring_for_validate,
-                    &mut signatures,
-                    &mut gossip_headers,
-                )?;
-                if !gossip_headers.is_null() {
-                    gossipped_addr =
-                        update_gossip_peerstates(context, message_time, imffields, gossip_headers)?;
-                }
+            let mut gossip_headers = ptr::null_mut();
+            encrypted = decrypt_if_autocrypt_message(
+                context,
+                in_out_message,
+                &private_keyring,
+                &public_keyring_for_validate,
+                &mut signatures,
+                &mut gossip_headers,
+            )?;
+            if !gossip_headers.is_null() {
+                gossipped_addr =
+                    update_gossip_peerstates(context, message_time, imffields, gossip_headers)?;
+                unsafe { mailimf_fields_free(gossip_headers) };
             }
         }
     }
-    if !gossip_headers.is_null() {
-        unsafe { mailimf_fields_free(gossip_headers) };
-    }
-
     Ok((encrypted, signatures, gossipped_addr))
 }
 
@@ -560,7 +533,7 @@ fn decrypt_if_autocrypt_message(
     // XXX better return parsed headers so that upstream
     // does not need to dive into mmime-stuff again.
     unsafe {
-        if (*ret_gossip_headers).is_null() && ret_valid_signatures.len() > 0 {
+        if (*ret_gossip_headers).is_null() && !ret_valid_signatures.is_empty() {
             let mut dummy: libc::size_t = 0;
             let mut test: *mut mailimf_fields = ptr::null_mut();
             if mailimf_envelope_and_optional_fields_parse(
@@ -600,22 +573,16 @@ fn decrypt_part(
         mime_transfer_encoding = enc;
     }
 
-    let (decoded_data, decoded_data_bytes) =
-        wrapmime::decode_dt_data(mime_data, mime_transfer_encoding)?;
+    let data: Vec<u8> = wrapmime::decode_dt_data(mime_data, mime_transfer_encoding)?;
 
-    // encrypted, non-NULL decoded data in decoded_data now ...
-    // Note that we need to take care of freeing decoded_data ourself,
-    // after encryption has been attempted.
     let mut ret_decrypted_mime = ptr::null_mut();
 
-    ensure!(!decoded_data.is_null(), "Missing data");
-    let data = unsafe { std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes) };
-    if has_decrypted_pgp_armor(data) {
+    if has_decrypted_pgp_armor(&data) {
         // we should only have one decryption happening
         ensure!(ret_valid_signatures.is_empty(), "corrupt signatures");
 
         let plain = match dc_pgp_pk_decrypt(
-            data,
+            &data,
             &private_keyring,
             &public_keyring_for_validate,
             Some(ret_valid_signatures),
@@ -624,10 +591,7 @@ fn decrypt_part(
                 ensure!(!ret_valid_signatures.is_empty(), "no valid signatures");
                 plain
             }
-            Err(err) => {
-                unsafe { mmap_string_unref(decoded_data) };
-                bail!("could not decrypt: {}", err)
-            }
+            Err(err) => bail!("could not decrypt: {}", err),
         };
         let plain_bytes = plain.len();
         let plain_buf = plain.as_ptr() as *const libc::c_char;
@@ -655,7 +619,6 @@ fn decrypt_part(
             ret_decrypted_mime = decrypted_mime;
         }
     }
-    unsafe { mmap_string_unref(decoded_data) };
 
     Ok(ret_decrypted_mime)
 }
@@ -723,12 +686,12 @@ fn contains_report(mime: *mut Mailmime) -> bool {
 /// If this succeeds you are also guaranteed that the
 /// [Config::ConfiguredAddr] is configured, this address is returned.
 pub fn ensure_secret_key_exists(context: &Context) -> Result<String> {
-    let self_addr = context
-        .get_config(Config::ConfiguredAddr)
-        .ok_or(format_err!(concat!(
+    let self_addr = context.get_config(Config::ConfiguredAddr).ok_or_else(|| {
+        format_err!(concat!(
             "Failed to get self address, ",
             "cannot ensure secret key if not configured."
-        )))?;
+        ))
+    })?;
     load_or_generate_self_public_key(context, &self_addr)?;
     Ok(self_addr)
 }

src/events.rs

@@ -42,6 +42,30 @@ pub enum Event {
     #[strum(props(id = "103"))]
     SmtpMessageSent(String),
 
+    /// Emitted when an IMAP message has been marked as deleted
+    ///
+    /// @return 0
+    #[strum(props(id = "104"))]
+    ImapMessageDeleted(String),
+
+    /// Emitted when an IMAP message has been moved
+    ///
+    /// @return 0
+    #[strum(props(id = "105"))]
+    ImapMessageMoved(String),
+
+    /// Emitted when an new file in the $BLOBDIR was created
+    ///
+    /// @return 0
+    #[strum(props(id = "150"))]
+    NewBlobFile(String),
+
+    /// Emitted when an new file in the $BLOBDIR was created
+    ///
+    /// @return 0
+    #[strum(props(id = "151"))]
+    DeletedBlobFile(String),
+
     /// The library-user should write a warning string to the log.
     /// Passed to the callback given to dc_context_new().
     ///

src/imap.rs

@@ -8,12 +8,14 @@ use std::time::{Duration, SystemTime};
 use crate::constants::*;
 use crate::context::Context;
 use crate::dc_receive_imf::dc_receive_imf;
+use crate::error::Error;
 use crate::events::Event;
-use crate::job::{job_add, Action};
-use crate::login_param::LoginParam;
+use crate::job::{connect_to_inbox, job_add, Action};
+use crate::login_param::{dc_build_tls, CertificateChecks, LoginParam};
 use crate::message::{self, update_msg_move_state, update_server_uid};
 use crate::oauth2::dc_get_oauth2_access_token;
 use crate::param::Params;
+use crate::wrapmime;
 
 const DC_IMAP_SEEN: usize = 0x0001;
 
@@ -27,7 +29,6 @@ pub enum ImapResult {
 
 const PREFETCH_FLAGS: &str = "(UID ENVELOPE)";
 const BODY_FLAGS: &str = "(FLAGS BODY.PEEK[])";
-const FETCH_FLAGS: &str = "(FLAGS)";
 
 #[derive(Debug)]
 pub struct Imap {
@@ -107,14 +108,10 @@ impl Client {
     pub fn connect_secure<A: net::ToSocketAddrs, S: AsRef<str>>(
         addr: A,
         domain: S,
+        certificate_checks: CertificateChecks,
     ) -> imap::error::Result<Self> {
         let stream = net::TcpStream::connect(addr)?;
-        let tls = native_tls::TlsConnector::builder()
-            // see also: https://github.com/deltachat/deltachat-core-rust/issues/203
-            .danger_accept_invalid_certs(true)
-            .danger_accept_invalid_hostnames(true)
-            .build()
-            .unwrap();
+        let tls = dc_build_tls(certificate_checks).unwrap();
 
         let s = stream.try_clone().expect("cloning the stream failed");
         let tls_stream = native_tls::TlsConnector::connect(&tls, domain.as_ref(), s)?;
@@ -134,13 +131,14 @@ impl Client {
         Ok(Client::Insecure(client, stream))
     }
 
-    pub fn secure<S: AsRef<str>>(self, domain: S) -> imap::error::Result<Client> {
+    pub fn secure<S: AsRef<str>>(
+        self,
+        domain: S,
+        certificate_checks: CertificateChecks,
+    ) -> imap::error::Result<Client> {
         match self {
             Client::Insecure(client, stream) => {
-                let tls = native_tls::TlsConnector::builder()
-                    .danger_accept_invalid_hostnames(true)
-                    .build()
-                    .unwrap();
+                let tls = dc_build_tls(certificate_checks).unwrap();
 
                 let client_sec = client.secure(domain, &tls)?;
 
@@ -320,6 +318,7 @@ struct ImapConfig {
     pub imap_port: u16,
     pub imap_user: String,
     pub imap_pw: String,
+    pub certificate_checks: CertificateChecks,
     pub server_flags: usize,
     pub selected_folder: Option<String>,
     pub selected_mailbox: Option<imap::types::Mailbox>,
@@ -332,12 +331,13 @@ struct ImapConfig {
 
 impl Default for ImapConfig {
     fn default() -> Self {
-        let cfg = ImapConfig {
+        ImapConfig {
             addr: "".into(),
             imap_server: "".into(),
             imap_port: 0,
             imap_user: "".into(),
             imap_pw: "".into(),
+            certificate_checks: Default::default(),
             server_flags: 0,
             selected_folder: None,
             selected_mailbox: None,
@@ -346,9 +346,7 @@ impl Default for ImapConfig {
             has_xlist: false,
             imap_delimiter: '.',
             watch_folder: None,
-        };
-
-        cfg
+        }
     }
 }
 
@@ -396,7 +394,7 @@ impl Imap {
 
                 Client::connect_insecure((imap_server, imap_port)).and_then(|client| {
                     if (server_flags & DC_LP_IMAP_SOCKET_STARTTLS) != 0 {
-                        client.secure(imap_server)
+                        client.secure(imap_server, config.certificate_checks)
                     } else {
                         Ok(client)
                     }
@@ -406,7 +404,11 @@ impl Imap {
                 let imap_server: &str = config.imap_server.as_ref();
                 let imap_port = config.imap_port;
 
-                Client::connect_secure((imap_server, imap_port), imap_server)
+                Client::connect_secure(
+                    (imap_server, imap_port),
+                    imap_server,
+                    config.certificate_checks,
+                )
             };
 
         let login_res = match connection_res {
@@ -533,6 +535,7 @@ impl Imap {
             config.imap_port = imap_port;
             config.imap_user = imap_user.to_string();
             config.imap_pw = imap_pw.to_string();
+            config.certificate_checks = lp.imap_certificate_checks;
             config.server_flags = server_flags;
         }
 
@@ -681,7 +684,7 @@ impl Imap {
                     }
                 }
             } else {
-                return 0;
+                unreachable!();
             }
         }
 
@@ -690,12 +693,20 @@ impl Imap {
 
     fn get_config_last_seen_uid<S: AsRef<str>>(&self, context: &Context, folder: S) -> (u32, u32) {
         let key = format!("imap.mailbox.{}", folder.as_ref());
-        if let Some(entry) = context.sql.get_config(context, &key) {
+        if let Some(entry) = context.sql.get_raw_config(context, &key) {
             // the entry has the format `imap.mailbox.<folder>=<uidvalidity>:<lastseenuid>`
             let mut parts = entry.split(':');
             (
-                parts.next().unwrap().parse().unwrap_or_else(|_| 0),
-                parts.next().unwrap().parse().unwrap_or_else(|_| 0),
+                parts
+                    .next()
+                    .unwrap_or_default()
+                    .parse()
+                    .unwrap_or_else(|_| 0),
+                parts
+                    .next()
+                    .unwrap_or_default()
+                    .parse()
+                    .unwrap_or_else(|_| 0),
             )
         } else {
             (0, 0)
@@ -739,7 +750,7 @@ impl Imap {
             return 0;
         }
 
-        if mailbox.uid_validity.unwrap() != uid_validity {
+        if mailbox.uid_validity.unwrap_or_default() != uid_validity {
             // first time this folder is selected or UIDVALIDITY has changed, init lastseenuid and save it to config
 
             if mailbox.exists == 0 {
@@ -749,7 +760,12 @@ impl Imap {
                 // id we do not do this here, we'll miss the first message
                 // as we will get in here again and fetch from lastseenuid+1 then
 
-                self.set_config_last_seen_uid(context, &folder, mailbox.uid_validity.unwrap(), 0);
+                self.set_config_last_seen_uid(
+                    context,
+                    &folder,
+                    mailbox.uid_validity.unwrap_or_default(),
+                    0,
+                );
                 return 0;
             }
 
@@ -780,7 +796,7 @@ impl Imap {
                 last_seen_uid -= 1;
             }
 
-            uid_validity = mailbox.uid_validity.unwrap();
+            uid_validity = mailbox.uid_validity.unwrap_or_default();
             self.set_config_last_seen_uid(context, &folder, uid_validity, last_seen_uid);
             info!(
                 context,
@@ -816,11 +832,7 @@ impl Imap {
             if cur_uid > last_seen_uid {
                 read_cnt += 1;
 
-                let message_id = msg
-                    .envelope()
-                    .expect("missing envelope")
-                    .message_id
-                    .expect("missing message id");
+                let message_id = prefetch_get_message_id(msg).unwrap_or_default();
 
                 if !precheck_imf(context, &message_id, folder.as_ref(), cur_uid) {
                     // check passed, go fetch the rest
@@ -885,7 +897,7 @@ impl Imap {
         let key = format!("imap.mailbox.{}", folder.as_ref());
         let val = format!("{}:{}", uidvalidity, lastseenuid);
 
-        context.sql.set_config(context, &key, Some(&val)).ok();
+        context.sql.set_raw_config(context, &key, Some(&val)).ok();
     }
 
     fn fetch_single_msg<S: AsRef<str>>(
@@ -933,27 +945,20 @@ impl Imap {
         } else {
             let msg = &msgs[0];
 
-            let is_deleted = msg
-                .flags()
-                .iter()
-                .find(|flag| match flag {
-                    imap::types::Flag::Deleted => true,
-                    _ => false,
-                })
-                .is_some();
-            let is_seen = msg
-                .flags()
-                .iter()
-                .find(|flag| match flag {
-                    imap::types::Flag::Seen => true,
-                    _ => false,
-                })
-                .is_some();
+            // XXX put flags into a set and pass them to dc_receive_imf
+            let is_deleted = msg.flags().iter().any(|flag| match flag {
+                imap::types::Flag::Deleted => true,
+                _ => false,
+            });
+            let is_seen = msg.flags().iter().any(|flag| match flag {
+                imap::types::Flag::Seen => true,
+                _ => false,
+            });
 
             let flags = if is_seen { DC_IMAP_SEEN } else { 0 };
 
             if !is_deleted && msg.body().is_some() {
-                let body = msg.body().unwrap();
+                let body = msg.body().unwrap_or_default();
                 unsafe {
                     dc_receive_imf(context, &body, folder.as_ref(), server_uid, flags as u32);
                 }
@@ -1064,13 +1069,14 @@ impl Imap {
         let mut do_fake_idle = true;
         while do_fake_idle {
             // wait a moment: every 5 seconds in the first 3 minutes after a new message, after that every 60 seconds.
-            let seconds_to_wait =
-                if fake_idle_start_time.elapsed().unwrap() < Duration::new(3 * 60, 0) && !wait_long
-                {
-                    Duration::new(5, 0)
-                } else {
-                    Duration::new(60, 0)
-                };
+            let seconds_to_wait = if fake_idle_start_time.elapsed().unwrap_or_default()
+                < Duration::new(3 * 60, 0)
+                && !wait_long
+            {
+                Duration::new(5, 0)
+            } else {
+                Duration::new(60, 0)
+            };
 
             let &(ref lock, ref cvar) = &*self.watch.clone();
             let mut watch = lock.lock().unwrap();
@@ -1119,117 +1125,94 @@ impl Imap {
         cvar.notify_one();
     }
 
-    pub fn mv<S1: AsRef<str>, S2: AsRef<str>>(
+    pub fn mv(
         &self,
         context: &Context,
-        folder: S1,
+        folder: &str,
         uid: u32,
-        dest_folder: S2,
+        dest_folder: &str,
         dest_uid: &mut u32,
     ) -> ImapResult {
-        let mut res = ImapResult::RetryLater;
+        if folder == dest_folder {
+            info!(
+                context,
+                "Skip moving message; message {}/{} is already in {}...", folder, uid, dest_folder,
+            );
+            return ImapResult::AlreadyDone;
+        }
+        if let Some(imapresult) = self.prepare_imap_operation_on_msg(context, folder, uid) {
+            return imapresult;
+        }
+        // we are connected, and the folder is selected
+
+        // XXX Rust-Imap provides no target uid on mv, so just set it to 0
+        *dest_uid = 0;
+
         let set = format!("{}", uid);
-
-        if uid == 0 {
-            res = ImapResult::Failed;
-        } else if folder.as_ref() == dest_folder.as_ref() {
-            info!(
-                context,
-                "Skip moving message; message {}/{} is already in {}...",
-                folder.as_ref(),
-                uid,
-                dest_folder.as_ref()
-            );
-
-            res = ImapResult::AlreadyDone;
-        } else {
-            info!(
-                context,
-                "Moving message {}/{} to {}...",
-                folder.as_ref(),
-                uid,
-                dest_folder.as_ref()
-            );
-
-            if self.select_folder(context, Some(folder.as_ref())) == 0 {
-                warn!(
-                    context,
-                    "Cannot select folder {} for moving message.",
-                    folder.as_ref()
-                );
-            } else {
-                let moved = if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
-                    match session.uid_mv(&set, &dest_folder) {
-                        Ok(_) => {
-                            res = ImapResult::Success;
-                            true
-                        }
-                        Err(err) => {
-                            info!(
-                                context,
-                                "Cannot move message, fallback to COPY/DELETE {}/{} to {}: {}",
-                                folder.as_ref(),
-                                uid,
-                                dest_folder.as_ref(),
-                                err
-                            );
-
-                            false
-                        }
-                    }
-                } else {
-                    unreachable!();
-                };
-
-                if !moved {
-                    let copied = if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
-                        match session.uid_copy(&set, &dest_folder) {
-                            Ok(_) => true,
-                            Err(err) => {
-                                eprintln!("error copy: {:?}", err);
-                                info!(context, "Cannot copy message.",);
-
-                                false
-                            }
-                        }
-                    } else {
-                        unreachable!();
-                    };
-
-                    if copied {
-                        if self.add_flag(context, uid, "\\Deleted") == 0 {
-                            warn!(context, "Cannot mark message as \"Deleted\".",);
-                        }
-                        self.config.write().unwrap().selected_folder_needs_expunge = true;
-                        res = ImapResult::Success;
-                    }
+        let display_folder_id = format!("{}/{}", folder, uid);
+        if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
+            match session.uid_mv(&set, &dest_folder) {
+                Ok(_) => {
+                    emit_event!(
+                        context,
+                        Event::ImapMessageMoved(format!(
+                            "IMAP Message {} moved to {}",
+                            display_folder_id, dest_folder
+                        ))
+                    );
+                    return ImapResult::Success;
+                }
+                Err(err) => {
+                    warn!(
+                        context,
+                        "Cannot move message, fallback to COPY/DELETE {}/{} to {}: {}",
+                        folder,
+                        uid,
+                        dest_folder,
+                        err
+                    );
                 }
             }
-        }
+        } else {
+            unreachable!();
+        };
 
-        if res == ImapResult::Success {
-            // TODO: is this correct?
-            *dest_uid = uid;
-        }
-
-        if res == ImapResult::RetryLater {
-            if self.should_reconnect() {
-                ImapResult::RetryLater
-            } else {
-                ImapResult::Failed
+        if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
+            match session.uid_copy(&set, &dest_folder) {
+                Ok(_) => {
+                    if !self.add_flag_finalized(context, uid, "\\Deleted") {
+                        warn!(context, "Cannot mark {} as \"Deleted\" after copy.", uid);
+                        ImapResult::Failed
+                    } else {
+                        self.config.write().unwrap().selected_folder_needs_expunge = true;
+                        ImapResult::Success
+                    }
+                }
+                Err(err) => {
+                    warn!(context, "Could not copy message: {}", err);
+                    ImapResult::Failed
+                }
             }
         } else {
-            res
+            unreachable!();
         }
     }
 
-    fn add_flag<S: AsRef<str>>(&self, context: &Context, server_uid: u32, flag: S) -> usize {
+    fn add_flag_finalized(&self, context: &Context, server_uid: u32, flag: &str) -> bool {
+        // return true if we successfully set the flag or we otherwise
+        // think add_flag should not be retried: Disconnection during setting
+        // the flag, or other imap-errors, returns true as well.
+        //
+        // returning false means that the operation can be retried.
         if server_uid == 0 {
-            return 0;
+            return true; // might be moved but we don't want to have a stuck job
+        }
+        if self.should_reconnect() {
+            return false;
         }
         if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
             let set = format!("{}", server_uid);
-            let query = format!("+FLAGS ({})", flag.as_ref());
+            let query = format!("+FLAGS ({})", flag);
             match session.uid_store(&set, &query) {
                 Ok(_) => {}
                 Err(err) => {
@@ -1239,243 +1222,126 @@ impl Imap {
                     );
                 }
             }
-        }
-
-        // All non-connection states are treated as success - the mail may
-        // already be deleted or moved away on the server.
-        if self.should_reconnect() {
-            0
+            true // we tried once, that's probably enough for setting flag
         } else {
-            1
+            unreachable!();
         }
     }
 
-    pub fn set_seen<S: AsRef<str>>(&self, context: &Context, folder: S, uid: u32) -> ImapResult {
-        let mut res = ImapResult::RetryLater;
-
+    pub fn prepare_imap_operation_on_msg(
+        &self,
+        context: &Context,
+        folder: &str,
+        uid: u32,
+    ) -> Option<ImapResult> {
         if uid == 0 {
-            res = ImapResult::Failed
-        } else if self.is_connected() {
-            info!(
-                context,
-                "Marking message {}/{} as seen...",
-                folder.as_ref(),
-                uid,
-            );
-
-            if self.select_folder(context, Some(folder.as_ref())) == 0 {
-                warn!(
-                    context,
-                    "Cannot select folder {} for setting SEEN flag.",
-                    folder.as_ref(),
-                );
-            } else if self.add_flag(context, uid, "\\Seen") == 0 {
-                warn!(context, "Cannot mark message as seen.",);
-            } else {
-                res = ImapResult::Success
+            return Some(ImapResult::Failed);
+        } else if !self.is_connected() {
+            connect_to_inbox(context, &self);
+            if !self.is_connected() {
+                return Some(ImapResult::RetryLater);
             }
         }
-
-        if res == ImapResult::RetryLater {
-            if self.should_reconnect() {
-                ImapResult::RetryLater
-            } else {
-                ImapResult::Failed
-            }
+        if self.select_folder(context, Some(&folder)) == 0 {
+            warn!(
+                context,
+                "Cannot select folder {} for preparing IMAP operation", folder
+            );
+            Some(ImapResult::RetryLater)
         } else {
-            res
+            None
         }
     }
 
-    pub fn set_mdnsent<S: AsRef<str>>(&self, context: &Context, folder: S, uid: u32) -> ImapResult {
-        // returns 0=job should be retried later, 1=job done, 2=job done and flag just set
-        let mut res = ImapResult::RetryLater;
-        let set = format!("{}", uid);
-
-        if uid == 0 {
-            res = ImapResult::Failed;
-        } else if self.is_connected() {
-            info!(
-                context,
-                "Marking message {}/{} as $MDNSent...",
-                folder.as_ref(),
-                uid,
-            );
-
-            if self.select_folder(context, Some(folder.as_ref())) == 0 {
-                warn!(
-                    context,
-                    "Cannot select folder {} for setting $MDNSent flag.",
-                    folder.as_ref()
-                );
-            } else {
-                // Check if the folder can handle the `$MDNSent` flag (see RFC 3503).  If so, and not
-                // set: set the flags and return this information.
-                // If the folder cannot handle the `$MDNSent` flag, we risk duplicated MDNs; it's up
-                // to the receiving MUA to handle this then (eg. Delta Chat has no problem with this).
-
-                let can_create_flag = self
-                    .config
-                    .read()
-                    .unwrap()
-                    .selected_mailbox
-                    .as_ref()
-                    .map(|mbox| {
-                        // empty means, everything can be stored
-                        mbox.permanent_flags.is_empty()
-                            || mbox
-                                .permanent_flags
-                                .iter()
-                                .find(|flag| match flag {
-                                    imap::types::Flag::Custom(s) => s == "$MDNSent",
-                                    _ => false,
-                                })
-                                .is_some()
-                    })
-                    .expect("just selected folder");
-
-                if can_create_flag {
-                    let fetched_msgs =
-                        if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
-                            match session.uid_fetch(set, FETCH_FLAGS) {
-                                Ok(res) => Some(res),
-                                Err(err) => {
-                                    eprintln!("fetch error: {:?}", err);
-                                    None
-                                }
-                            }
-                        } else {
-                            unreachable!();
-                        };
-
-                    if let Some(msgs) = fetched_msgs {
-                        let flag_set = msgs
-                            .first()
-                            .map(|msg| {
-                                msg.flags()
-                                    .iter()
-                                    .find(|flag| match flag {
-                                        imap::types::Flag::Custom(s) => s == "$MDNSent",
-                                        _ => false,
-                                    })
-                                    .is_some()
-                            })
-                            .unwrap_or_else(|| false);
-
-                        res = if flag_set {
-                            ImapResult::AlreadyDone
-                        } else if self.add_flag(context, uid, "$MDNSent") != 0 {
-                            ImapResult::Success
-                        } else {
-                            res
-                        };
-
-                        if res == ImapResult::Success {
-                            info!(context, "$MDNSent just set and MDN will be sent.");
-                        } else {
-                            info!(context, "$MDNSent already set and MDN already sent.");
-                        }
-                    }
-                } else {
-                    res = ImapResult::Success;
-                    info!(
-                        context,
-                        "Cannot store $MDNSent flags, risk sending duplicate MDN.",
-                    );
-                }
-            }
+    pub fn set_seen(&self, context: &Context, folder: &str, uid: u32) -> ImapResult {
+        if let Some(imapresult) = self.prepare_imap_operation_on_msg(context, folder, uid) {
+            return imapresult;
         }
+        // we are connected, and the folder is selected
+        info!(context, "Marking message {}/{} as seen...", folder, uid,);
 
-        if res == ImapResult::RetryLater {
-            if self.should_reconnect() {
-                ImapResult::RetryLater
-            } else {
-                ImapResult::Failed
-            }
+        if self.add_flag_finalized(context, uid, "\\Seen") {
+            ImapResult::Success
         } else {
-            res
+            warn!(
+                context,
+                "Cannot mark message {} in folder {} as seen, ignoring.", uid, folder
+            );
+            ImapResult::Failed
         }
     }
 
     // only returns 0 on connection problems; we should try later again in this case *
-    pub fn delete_msg<S1: AsRef<str>, S2: AsRef<str>>(
+    pub fn delete_msg(
         &self,
         context: &Context,
-        message_id: S1,
-        folder: S2,
-        server_uid: &mut u32,
-    ) -> usize {
-        let mut success = false;
-        if *server_uid == 0 {
-            success = true
-        } else {
-            info!(
-                context,
-                "Marking message \"{}\", {}/{} for deletion...",
-                message_id.as_ref(),
-                folder.as_ref(),
-                server_uid,
-            );
+        message_id: &str,
+        folder: &str,
+        uid: &mut u32,
+    ) -> ImapResult {
+        if let Some(imapresult) = self.prepare_imap_operation_on_msg(context, folder, *uid) {
+            return imapresult;
+        }
+        // we are connected, and the folder is selected
 
-            if self.select_folder(context, Some(&folder)) == 0 {
-                warn!(
-                    context,
-                    "Cannot select folder {} for deleting message.",
-                    folder.as_ref()
-                );
-            } else {
-                let set = format!("{}", server_uid);
-                if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
-                    match session.uid_fetch(set, PREFETCH_FLAGS) {
-                        Ok(msgs) => {
-                            if msgs.is_empty()
-                                || msgs
-                                    .first()
-                                    .unwrap()
-                                    .envelope()
-                                    .expect("missing envelope")
-                                    .message_id
-                                    .expect("missing message id")
-                                    != message_id.as_ref()
-                            {
-                                warn!(
-                                    context,
-                                    "Cannot delete on IMAP, {}/{} does not match {}.",
-                                    folder.as_ref(),
-                                    server_uid,
-                                    message_id.as_ref(),
-                                );
-                                *server_uid = 0;
-                            }
-                        }
-                        Err(err) => {
-                            eprintln!("fetch error: {:?}", err);
+        let set = format!("{}", uid);
+        let display_imap_id = format!("{}/{}", folder, uid);
 
-                            warn!(
-                                context,
-                                "Cannot delete on IMAP, {}/{} not found.",
-                                folder.as_ref(),
-                                server_uid,
-                            );
-                            *server_uid = 0;
-                        }
+        // double-check that we are deleting the correct message-id
+        // this comes at the expense of another imap query
+        if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
+            match session.uid_fetch(set, PREFETCH_FLAGS) {
+                Ok(msgs) => {
+                    if msgs.is_empty() {
+                        warn!(
+                            context,
+                            "Cannot delete on IMAP, {}: imap entry gone '{}'",
+                            display_imap_id,
+                            message_id,
+                        );
+                        return ImapResult::Failed;
                     }
-                }
+                    let remote_message_id =
+                        prefetch_get_message_id(msgs.first().unwrap()).unwrap_or_default();
 
-                // mark the message for deletion
-                if self.add_flag(context, *server_uid, "\\Deleted") == 0 {
-                    warn!(context, "Cannot mark message as \"Deleted\".");
-                } else {
-                    self.config.write().unwrap().selected_folder_needs_expunge = true;
-                    success = true
+                    if remote_message_id != message_id {
+                        warn!(
+                            context,
+                            "Cannot delete on IMAP, {}: remote message-id '{}' != '{}'",
+                            display_imap_id,
+                            remote_message_id,
+                            message_id,
+                        );
+                    }
+                    *uid = 0;
+                }
+                Err(err) => {
+                    warn!(
+                        context,
+                        "Cannot delete {} on IMAP: {}", display_imap_id, err
+                    );
+                    *uid = 0;
                 }
             }
         }
 
-        if success {
-            1
+        // mark the message for deletion
+        if !self.add_flag_finalized(context, *uid, "\\Deleted") {
+            warn!(
+                context,
+                "Cannot mark message {} as \"Deleted\".", display_imap_id
+            );
+            ImapResult::Failed
         } else {
-            self.is_connected() as usize
+            emit_event!(
+                context,
+                Event::ImapMessageDeleted(format!(
+                    "IMAP Message {} marked as deleted [{}]",
+                    display_imap_id, message_id
+                ))
+            );
+            self.config.write().unwrap().selected_folder_needs_expunge = true;
+            ImapResult::Success
         }
     }
 
@@ -1544,18 +1410,18 @@ impl Imap {
 
         context
             .sql
-            .set_config_int(context, "folders_configured", 3)
+            .set_raw_config_int(context, "folders_configured", 3)
             .ok();
         if let Some(ref mvbox_folder) = mvbox_folder {
             context
                 .sql
-                .set_config(context, "configured_mvbox_folder", Some(mvbox_folder))
+                .set_raw_config(context, "configured_mvbox_folder", Some(mvbox_folder))
                 .ok();
         }
         if let Some(ref sentbox_folder) = sentbox_folder {
             context
                 .sql
-                .set_config(
+                .set_raw_config(
                     context,
                     "configured_sentbox_folder",
                     Some(sentbox_folder.name()),
@@ -1635,27 +1501,11 @@ fn get_folder_meaning(folder_name: &imap::types::Name) -> FolderMeaning {
 }
 
 fn precheck_imf(context: &Context, rfc724_mid: &str, server_folder: &str, server_uid: u32) -> bool {
-    let mut rfc724_mid_exists = false;
-    let mut mark_seen = false;
-
     if let Ok((old_server_folder, old_server_uid, msg_id)) =
         message::rfc724_mid_exists(context, &rfc724_mid)
     {
-        rfc724_mid_exists = true;
-
         if old_server_folder.is_empty() && old_server_uid == 0 {
             info!(context, "[move] detected bbc-self {}", rfc724_mid,);
-            mark_seen = true;
-        } else if old_server_folder != server_folder {
-            info!(context, "[move] detected moved message {}", rfc724_mid,);
-            update_msg_move_state(context, &rfc724_mid, MoveState::Stay);
-        }
-        if old_server_folder != server_folder || old_server_uid != server_uid {
-            update_server_uid(context, &rfc724_mid, server_folder, server_uid);
-        }
-        context.do_heuristics_moves(server_folder, msg_id);
-
-        if mark_seen {
             job_add(
                 context,
                 Action::MarkseenMsgOnImap,
@@ -1663,8 +1513,21 @@ fn precheck_imf(context: &Context, rfc724_mid: &str, server_folder: &str, server
                 Params::new(),
                 0,
             );
+        } else if old_server_folder != server_folder {
+            info!(context, "[move] detected moved message {}", rfc724_mid,);
+            update_msg_move_state(context, &rfc724_mid, MoveState::Stay);
         }
-    }
 
-    rfc724_mid_exists
+        if old_server_folder != server_folder || old_server_uid != server_uid {
+            update_server_uid(context, &rfc724_mid, server_folder, server_uid);
+        }
+        true
+    } else {
+        false
+    }
+}
+
+fn prefetch_get_message_id(prefetch_msg: &imap::types::Fetch) -> Result<String, Error> {
+    let message_id = prefetch_msg.envelope().unwrap().message_id.unwrap();
+    wrapmime::parse_message_id(&message_id)
 }

src/imex.rs

@@ -1,5 +1,6 @@
+use core::cmp::{max, min};
 use std::ffi::CString;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::ptr;
 
 use num_traits::FromPrimitive;
@@ -90,7 +91,7 @@ pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<Strin
                     let sql = Sql::new();
                     if sql.open(context, &path, 0x1) {
                         let curr_backup_time =
-                            sql.get_config_int(context, "backup_time")
+                            sql.get_raw_config_int(context, "backup_time")
                                 .unwrap_or_default() as u64;
                         if curr_backup_time > newest_backup_time {
                             newest_backup_path = Some(path);
@@ -109,78 +110,48 @@ pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<Strin
 }
 
 pub fn initiate_key_transfer(context: &Context) -> Result<String> {
+    ensure!(context.alloc_ongoing(), "could not allocate ongoing");
+    let res = do_initiate_key_transfer(context);
+    context.free_ongoing();
+    res
+}
+
+fn do_initiate_key_transfer(context: &Context) -> Result<String> {
     let mut msg: Message;
-    ensure!(dc_alloc_ongoing(context), "could not allocate ongoing");
     let setup_code = create_setup_code(context);
     /* this may require a keypair to be created. this may take a second ... */
-    if !context
-        .running_state
-        .clone()
-        .read()
-        .unwrap()
-        .shall_stop_ongoing
-    {
-        if let Ok(ref setup_file_content) = render_setup_file(context, &setup_code) {
-            /* encrypting may also take a while ... */
-            if !context
-                .running_state
-                .clone()
-                .read()
-                .unwrap()
-                .shall_stop_ongoing
-            {
-                let setup_file_name = context.new_blob_file(
-                    "autocrypt-setup-message.html",
-                    setup_file_content.as_bytes(),
-                )?;
-                {
-                    if let Ok(chat_id) = chat::create_by_contact_id(context, 1) {
-                        msg = Message::default();
-                        msg.type_0 = Viewtype::File;
-                        msg.param.set(Param::File, setup_file_name);
+    ensure!(!context.shall_stop_ongoing(), "canceled");
+    let setup_file_content = render_setup_file(context, &setup_code)?;
+    /* encrypting may also take a while ... */
+    ensure!(!context.shall_stop_ongoing(), "canceled");
+    let setup_file_name = context.new_blob_file(
+        "autocrypt-setup-message.html",
+        setup_file_content.as_bytes(),
+    )?;
 
-                        msg.param
-                            .set(Param::MimeType, "application/autocrypt-setup");
-                        msg.param.set_int(Param::Cmd, 6);
-                        msg.param
-                            .set_int(Param::ForcePlaintext, DC_FP_NO_AUTOCRYPT_HEADER);
+    let chat_id = chat::create_by_contact_id(context, 1)?;
+    msg = Message::default();
+    msg.type_0 = Viewtype::File;
+    msg.param.set(Param::File, setup_file_name);
 
-                        if !context
-                            .running_state
-                            .clone()
-                            .read()
-                            .unwrap()
-                            .shall_stop_ongoing
-                        {
-                            if let Ok(msg_id) = chat::send_msg(context, chat_id, &mut msg) {
-                                info!(context, "Wait for setup message being sent ...",);
-                                loop {
-                                    if context
-                                        .running_state
-                                        .clone()
-                                        .read()
-                                        .unwrap()
-                                        .shall_stop_ongoing
-                                    {
-                                        break;
-                                    }
-                                    std::thread::sleep(std::time::Duration::from_secs(1));
-                                    if let Ok(msg) = Message::load_from_db(context, msg_id) {
-                                        if msg.is_sent() {
-                                            info!(context, "... setup message sent.",);
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+    msg.param
+        .set(Param::MimeType, "application/autocrypt-setup");
+    msg.param.set_int(Param::Cmd, 6);
+    msg.param
+        .set_int(Param::ForcePlaintext, DC_FP_NO_AUTOCRYPT_HEADER);
+
+    ensure!(!context.shall_stop_ongoing(), "canceled");
+    let msg_id = chat::send_msg(context, chat_id, &mut msg)?;
+    info!(context, "Wait for setup message being sent ...",);
+    while !context.shall_stop_ongoing() {
+        std::thread::sleep(std::time::Duration::from_secs(1));
+        if let Ok(msg) = Message::load_from_db(context, msg_id) {
+            if msg.is_sent() {
+                info!(context, "... setup message sent.",);
+                break;
             }
         }
     }
-    dc_free_ongoing(context);
-
     Ok(setup_code)
 }
 
@@ -195,13 +166,9 @@ pub fn render_setup_file(context: &Context, passphrase: &str) -> Result<String>
     let self_addr = e2ee::ensure_secret_key_exists(context)?;
     let private_key = Key::from_self_private(context, self_addr, &context.sql)
         .ok_or(format_err!("Failed to get private key."))?;
-    let ac_headers = match context
-        .sql
-        .get_config_int(context, Config::E2eeEnabled)
-        .unwrap_or(1)
-    {
-        0 => None,
-        _ => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
+    let ac_headers = match context.get_config_bool(Config::E2eeEnabled) {
+        false => None,
+        true => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
     };
     let private_key_asc = private_key.to_asc(ac_headers);
     let encr = dc_pgp_symm_encrypt(&passphrase, private_key_asc.as_bytes())?;
@@ -267,7 +234,7 @@ pub fn continue_key_transfer(context: &Context, msg_id: u32, setup_code: &str) -
     if msg.is_err() {
         bail!("Message is no Autocrypt Setup Message.");
     }
-    let msg = msg.unwrap();
+    let msg = msg.unwrap_or_default();
     ensure!(
         msg.is_setupmessage(),
         "Message is no Autocrypt Setup Message."
@@ -317,7 +284,7 @@ fn set_self_key(
             };
             context
                 .sql
-                .set_config_int(context, "e2ee_enabled", e2ee_enabled)?;
+                .set_raw_config_int(context, "e2ee_enabled", e2ee_enabled)?;
         }
         None => {
             if prefer_encrypt_required {
@@ -350,7 +317,7 @@ fn set_self_key(
         context,
         &public_key,
         &private_key,
-        self_addr.unwrap(),
+        self_addr.unwrap_or_default(),
         set_default,
         &context.sql,
     ) {
@@ -423,7 +390,7 @@ pub fn normalize_setup_code(s: &str) -> String {
 
 #[allow(non_snake_case)]
 pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
-    ensure!(dc_alloc_ongoing(context), "could not allocate ongoing");
+    ensure!(context.alloc_ongoing(), "could not allocate ongoing");
     let what: Option<ImexMode> = job.param.get_int(Param::Cmd).and_then(ImexMode::from_i32);
     let param = job.param.get(Param::Arg).unwrap_or_default();
 
@@ -435,7 +402,7 @@ pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     if what == Some(ImexMode::ExportBackup) || what == Some(ImexMode::ExportSelfKeys) {
         // before we export anything, make sure the private key exists
         if e2ee::ensure_secret_key_exists(context).is_err() {
-            dc_free_ongoing(context);
+            context.free_ongoing();
             bail!("Cannot create private key or private key not available.");
         } else {
             dc_create_folder(context, &param);
@@ -451,7 +418,7 @@ pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
             bail!("unknown IMEX type");
         }
     };
-    dc_free_ongoing(context);
+    context.free_ongoing();
     match success {
         Ok(()) => {
             info!(context, "IMEX successfully completed");
@@ -478,7 +445,7 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
         !dc_is_configured(context),
         "Cannot import backups to accounts in use."
     );
-    &context.sql.close(&context);
+    context.sql.close(&context);
     dc_delete_file(context, context.get_dbfile());
     ensure!(
         !dc_file_exist(context, context.get_dbfile()),
@@ -515,20 +482,9 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
             Ok((name, blob))
         },
         |files| {
-            let mut processed_files_cnt = 0;
-
-            for file in files {
+            for (processed_files_cnt, file) in files.enumerate() {
                 let (file_name, file_blob) = file?;
-                if context
-                    .running_state
-                    .clone()
-                    .read()
-                    .unwrap()
-                    .shall_stop_ongoing
-                {
-                    bail!("received stop signal");
-                }
-                processed_files_cnt += 1;
+                ensure!(!context.shall_stop_ongoing(), "received stop signal");
                 let mut permille = processed_files_cnt * 1000 / total_files_cnt;
                 if permille < 10 {
                     permille = 10
@@ -569,10 +525,6 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
 /* the FILE_PROGRESS macro calls the callback with the permille of files processed.
 The macro avoids weird values of 0% or 100% while still working. */
 fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
-    let mut ok_to_continue = true;
-    let mut success = false;
-
-    let mut delete_dest_file: libc::c_int = 0;
     // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
     // FIXME: we should write to a temporary file first and rename it on success. this would guarantee the backup is complete.
     // let dest_path_filename = dc_get_next_backup_file(context, dir, res);
@@ -599,130 +551,79 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
             s
         );
     }
-    /* 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*/
+    match add_files_to_export(context, &dest_path_filename) {
+        Err(err) => {
+            dc_delete_file(context, &dest_path_filename);
+            error!(context, "backup failed: {}", err);
+            Err(err)
+        }
+        Ok(()) => {
+            context
+                .sql
+                .set_raw_config_int(context, "backup_time", now as i32)?;
+            context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
+            Ok(())
+        }
+    }
+}
+
+fn add_files_to_export(context: &Context, dest_path_filename: &PathBuf) -> Result<()> {
+    // add all files as blobs to the database copy (this does not require
+    // the source to be locked, neigher the destination as it is used only here)
     let sql = Sql::new();
-    if sql.open(context, &dest_path_filename, 0) {
-        if !sql.table_exists("backup_blobs") {
-            if sql::execute(
-                context,
-                &sql,
-                "CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);",
-                params![],
-            )
-            .is_err()
-            {
-                /* error already logged */
-                ok_to_continue = false;
-            }
-        }
-        if ok_to_continue {
-            let mut total_files_cnt = 0;
-            let dir = context.get_blobdir();
-            if let Ok(dir_handle) = std::fs::read_dir(&dir) {
-                total_files_cnt += dir_handle.filter(|r| r.is_ok()).count();
+    ensure!(
+        sql.open(context, &dest_path_filename, 0),
+        "could not open db"
+    );
+    if !sql.table_exists("backup_blobs") {
+        sql::execute(
+            context,
+            &sql,
+            "CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);",
+            params![],
+        )?
+    }
+    // copy all files from BLOBDIR into backup-db
+    let mut total_files_cnt = 0;
+    let dir = context.get_blobdir();
+    let dir_handle = std::fs::read_dir(&dir)?;
+    total_files_cnt += dir_handle.filter(|r| r.is_ok()).count();
 
-                info!(context, "EXPORT: total_files_cnt={}", total_files_cnt);
-                if total_files_cnt > 0 {
-                    // scan directory, pass 2: copy files
-                    if let Ok(dir_handle) = std::fs::read_dir(&dir) {
-                        sql.prepare(
-                                    "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
-                                    move |mut stmt, _| {
-                                        let mut processed_files_cnt = 0;
-                                        for entry in dir_handle {
-                                            if entry.is_err() {
-                                                break;
-                                            }
-                                            let entry = entry.unwrap();
-                                            if context
-                                                .running_state
-                                                .clone()
-                                                .read()
-                                                .unwrap()
-                                                .shall_stop_ongoing
-                                            {
-                                                delete_dest_file = 1;
-                                                ok_to_continue = false;
-                                                break;
-                                            } else {
-                                                processed_files_cnt += 1;
-                                                let mut permille =
-                                                    processed_files_cnt * 1000 / total_files_cnt;
-                                                if permille < 10 {
-                                                    permille = 10;
-                                                }
-                                                if permille > 990 {
-                                                    permille = 990;
-                                                }
-                                                context.call_cb(Event::ImexProgress(permille));
-
-                                                let name_f = entry.file_name();
-                                                let name = name_f.to_string_lossy();
-                                                if name.starts_with("delta-chat") && name.ends_with(".bak")
-                                                {
-                                                    continue;
-                                                } else {
-                                                    info!(context, "EXPORTing filename={}", name);
-                                                    let curr_path_filename = context.get_blobdir().join(entry.file_name());
-                                                    if let Ok(buf) =
-                                                        dc_read_file(context, &curr_path_filename)
-                                                    {
-                                                        if buf.is_empty() {
-                                                            continue;
-                                                        }
-                                                        if stmt.execute(params![name, buf]).is_err() {
-                                                            error!(
-                                                                context,
-                                                                "Disk full? Cannot add file \"{}\" to backup.",
-                                                                curr_path_filename.display(),
-                                                            );
-                                                            /* this is not recoverable! writing to the sqlite database should work! */
-                                                            ok_to_continue = false;
-                                                            break;
-                                                        }
-                                                    } else {
-                                                        continue;
-                                                    }
-                                                }
-                                            }
-                                        }
-                                        Ok(())
-                                    }
-                                ).unwrap();
-                    } else {
-                        error!(
-                            context,
-                            "Backup: Cannot copy from blob-directory \"{}\".",
-                            context.get_blobdir().display(),
-                        );
-                    }
-                } else {
-                    info!(context, "Backup: No files to copy.",);
-                }
-                if ok_to_continue {
-                    if sql
-                        .set_config_int(context, "backup_time", now as i32)
-                        .is_ok()
-                    {
-                        context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
-                        success = true;
-                    }
-                }
-            } else {
-                error!(
-                    context,
-                    "Backup: Cannot get info for blob-directory \"{}\".",
-                    context.get_blobdir().display(),
+    info!(context, "EXPORT: total_files_cnt={}", total_files_cnt);
+    // scan directory, pass 2: copy files
+    let dir_handle = std::fs::read_dir(&dir)?;
+    sql.prepare(
+        "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
+        |mut stmt, _| {
+            let mut processed_files_cnt = 0;
+            for entry in dir_handle {
+                let entry = entry?;
+                ensure!(
+                    !context.shall_stop_ongoing(),
+                    "canceled during export-files"
                 );
-            };
-        }
-    }
-    if 0 != delete_dest_file {
-        dc_delete_file(context, &dest_path_filename);
-    }
+                processed_files_cnt += 1;
+                let permille = max(min(processed_files_cnt * 1000 / total_files_cnt, 990), 10);
+                context.call_cb(Event::ImexProgress(permille));
 
-    ensure!(success, "failed");
+                let name_f = entry.file_name();
+                let name = name_f.to_string_lossy();
+                if name.starts_with("delta-chat") && name.ends_with(".bak") {
+                    continue;
+                }
+                info!(context, "EXPORT: copying filename={}", name);
+                let curr_path_filename = context.get_blobdir().join(entry.file_name());
+                if let Ok(buf) = dc_read_file(context, &curr_path_filename) {
+                    if buf.is_empty() {
+                        continue;
+                    }
+                    // bail out if we can't insert
+                    stmt.execute(params![name, buf])?;
+                }
+            }
+            Ok(())
+        },
+    )?;
     Ok(())
 }
 
@@ -741,77 +642,68 @@ fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     let mut imported_cnt = 0;
 
     let dir_name = dir.as_ref().to_string_lossy();
-    if let Ok(dir_handle) = std::fs::read_dir(&dir) {
-        for entry in dir_handle {
-            let entry_fn = match entry {
-                Err(err) => {
-                    info!(context, "file-dir error: {}", err);
-                    break;
-                }
-                Ok(res) => res.file_name(),
-            };
-            let name_f = entry_fn.to_string_lossy();
-            let path_plus_name = dir.as_ref().join(&entry_fn);
-            match dc_get_filesuffix_lc(&name_f) {
-                Some(suffix) => {
-                    if suffix != "asc" {
-                        continue;
-                    }
-                    set_default = if name_f.contains("legacy") {
-                        info!(context, "found legacy key '{}'", path_plus_name.display());
-                        false
-                    } else {
-                        true
-                    }
-                }
-                None => {
+    let dir_handle = std::fs::read_dir(&dir)?;
+    for entry in dir_handle {
+        let entry_fn = entry?.file_name();
+        let name_f = entry_fn.to_string_lossy();
+        let path_plus_name = dir.as_ref().join(&entry_fn);
+        match dc_get_filesuffix_lc(&name_f) {
+            Some(suffix) => {
+                if suffix != "asc" {
                     continue;
                 }
+                set_default = if name_f.contains("legacy") {
+                    info!(context, "found legacy key '{}'", path_plus_name.display());
+                    false
+                } else {
+                    true
+                }
             }
-            let ccontent = if let Ok(content) = dc_read_file(context, &path_plus_name) {
-                key = String::from_utf8_lossy(&content).to_string();
-                CString::new(content).unwrap()
-            } else {
-                continue;
-            };
-
-            /* only import if we have a private key */
-            let mut buf2_headerline = String::default();
-            let split_res: bool;
-            unsafe {
-                let buf2 = dc_strdup(ccontent.as_ptr());
-                split_res = dc_split_armored_data(
-                    buf2,
-                    &mut buf2_headerline,
-                    ptr::null_mut(),
-                    ptr::null_mut(),
-                    ptr::null_mut(),
-                );
-                libc::free(buf2 as *mut libc::c_void);
-            }
-            if split_res
-                && buf2_headerline.contains("-----BEGIN PGP PUBLIC KEY BLOCK-----")
-                && !key.contains("-----BEGIN PGP PRIVATE KEY BLOCK")
-            {
-                info!(context, "ignoring public key file '{}", name_f);
-                // it's fine: DC exports public with private
+            None => {
                 continue;
             }
-            if let Err(err) = set_self_key(context, &key, set_default, false) {
-                error!(context, "set_self_key: {}", err);
-                continue;
-            }
-            imported_cnt += 1
         }
-        ensure!(
-            imported_cnt > 0,
-            "No private keys found in \"{}\".",
-            dir_name
-        );
-        return Ok(());
-    } else {
-        bail!("Import: Cannot open directory \"{}\".", dir_name);
+        let ccontent = if let Ok(content) = dc_read_file(context, &path_plus_name) {
+            key = String::from_utf8_lossy(&content).to_string();
+            CString::new(content).unwrap_or_default()
+        } else {
+            continue;
+        };
+
+        /* only import if we have a private key */
+        let mut buf2_headerline = String::default();
+        let split_res: bool;
+        unsafe {
+            let buf2 = dc_strdup(ccontent.as_ptr());
+            split_res = dc_split_armored_data(
+                buf2,
+                &mut buf2_headerline,
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+            );
+            libc::free(buf2 as *mut libc::c_void);
+        }
+        if split_res
+            && buf2_headerline.contains("-----BEGIN PGP PUBLIC KEY BLOCK-----")
+            && !key.contains("-----BEGIN PGP PRIVATE KEY BLOCK")
+        {
+            info!(context, "ignoring public key file '{}", name_f);
+            // it's fine: DC exports public with private
+            continue;
+        }
+        if let Err(err) = set_self_key(context, &key, set_default, false) {
+            error!(context, "set_self_key: {}", err);
+            continue;
+        }
+        imported_cnt += 1
     }
+    ensure!(
+        imported_cnt > 0,
+        "No private keys found in \"{}\".",
+        dir_name
+    );
+    Ok(())
 }
 
 fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
@@ -854,7 +746,7 @@ fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
         },
     )?;
 
-    ensure!(export_errors == 0, "errors while importing");
+    ensure!(export_errors == 0, "errors while exporting keys");
     Ok(())
 }
 
@@ -985,16 +877,17 @@ mod tests {
         let mut setupcodebegin = ptr::null();
         let mut preferencrypt = ptr::null();
 
-        let mut buf_1 = S_EM_SETUPFILE.to_string();
-
         unsafe {
-            assert!(dc_split_armored_data(
-                buf_1.as_mut_ptr().cast(),
+            let buf_1 = S_EM_SETUPFILE.strdup();
+            let res = dc_split_armored_data(
+                buf_1,
                 &mut headerline,
                 &mut setupcodebegin,
                 &mut preferencrypt,
                 ptr::null_mut(),
-            ));
+            );
+            libc::free(buf_1 as *mut libc::c_void);
+            assert!(res);
         }
         assert_eq!(headerline, "-----BEGIN PGP MESSAGE-----");
         assert!(!setupcodebegin.is_null());
@@ -1005,18 +898,20 @@ mod tests {
         assert!(preferencrypt.is_null());
 
         let mut setup_file = S_EM_SETUPFILE.to_string();
-        let mut decrypted = unsafe {
+        let decrypted = unsafe {
             decrypt_setup_file(context, S_EM_SETUPCODE, setup_file.as_bytes_mut()).unwrap()
         };
 
         unsafe {
+            let buf1 = decrypted.strdup();
             assert!(dc_split_armored_data(
-                decrypted.as_mut_ptr().cast(),
+                buf1,
                 &mut headerline,
                 &mut setupcodebegin,
                 &mut preferencrypt,
                 ptr::null_mut(),
             ));
+            libc::free(buf1 as *mut libc::c_void);
         }
 
         assert_eq!(headerline, "-----BEGIN PGP PRIVATE KEY BLOCK-----");

src/job.rs

@@ -4,10 +4,12 @@ use deltachat_derive::{FromSql, ToSql};
 use rand::{thread_rng, Rng};
 
 use crate::chat;
+use crate::config::Config;
 use crate::configure::*;
 use crate::constants::*;
 use crate::context::Context;
 use crate::dc_tools::*;
+use crate::error::Error;
 use crate::events::Event;
 use crate::imap::*;
 use crate::imex::*;
@@ -140,11 +142,11 @@ impl Job {
             if let Ok(body) = dc_read_file(context, filename) {
                 if let Some(recipients) = self.param.get(Param::Recipients) {
                     let recipients_list = recipients
-                        .split("\x1e")
+                        .split('\x1e')
                         .filter_map(|addr| match lettre::EmailAddress::new(addr.to_string()) {
                             Ok(addr) => Some(addr),
                             Err(err) => {
-                                eprintln!("WARNING: invalid recipient: {} {:?}", addr, err);
+                                warn!(context, "invalid recipient: {} {:?}", addr, err);
                                 None
                             }
                         })
@@ -156,39 +158,45 @@ impl Job {
                     if 0 != self.foreign_id && !message::exists(context, self.foreign_id) {
                         warn!(
                             context,
-                            "Message {} for job {} does not exist", self.foreign_id, self.job_id,
+                            "Not sending Message {} as it was deleted", self.foreign_id
                         );
                         return;
                     };
 
                     // hold the smtp lock during sending of a job and
                     // its ok/error response processing. Note that if a message
-                    // was sent we need to mark it in the database as we
+                    // was sent we need to mark it in the database ASAP as we
                     // otherwise might send it twice.
                     let mut sock = context.smtp.lock().unwrap();
-                    if 0 == sock.send(context, recipients_list, body) {
-                        sock.disconnect();
-                        self.try_again_later(-1i32, sock.error.clone());
-                    } else {
-                        dc_delete_file(context, filename);
-                        if 0 != self.foreign_id {
-                            message::update_msg_state(
-                                context,
-                                self.foreign_id,
-                                MessageState::OutDelivered,
-                            );
-                            let chat_id: i32 = context
-                                .sql
-                                .query_get_value(
+                    match sock.send(context, recipients_list, body) {
+                        Err(err) => {
+                            sock.disconnect();
+                            warn!(context, "smtp failed: {}", err);
+                            self.try_again_later(-1i32, Some(err.to_string()));
+                        }
+                        Ok(()) => {
+                            // smtp success, update db ASAP, then delete smtp file
+                            if 0 != self.foreign_id {
+                                message::update_msg_state(
                                     context,
-                                    "SELECT chat_id FROM msgs WHERE id=?",
-                                    params![self.foreign_id as i32],
-                                )
-                                .unwrap_or_default();
-                            context.call_cb(Event::MsgDelivered {
-                                chat_id: chat_id as u32,
-                                msg_id: self.foreign_id,
-                            });
+                                    self.foreign_id,
+                                    MessageState::OutDelivered,
+                                );
+                                let chat_id: i32 = context
+                                    .sql
+                                    .query_get_value(
+                                        context,
+                                        "SELECT chat_id FROM msgs WHERE id=?",
+                                        params![self.foreign_id as i32],
+                                    )
+                                    .unwrap_or_default();
+                                context.call_cb(Event::MsgDelivered {
+                                    chat_id: chat_id as u32,
+                                    msg_id: self.foreign_id,
+                                });
+                            }
+                            // now also delete the generated file
+                            dc_delete_file(context, filename);
                         }
                     }
                 } else {
@@ -208,23 +216,18 @@ impl Job {
     fn do_DC_JOB_MOVE_MSG(&mut self, context: &Context) {
         let inbox = context.inbox.read().unwrap();
 
-        if !inbox.is_connected() {
-            connect_to_inbox(context, &inbox);
-            if !inbox.is_connected() {
-                self.try_again_later(3, None);
-                return;
-            }
-        }
         if let Ok(msg) = Message::load_from_db(context, self.foreign_id) {
             if context
                 .sql
-                .get_config_int(context, "folders_configured")
+                .get_raw_config_int(context, "folders_configured")
                 .unwrap_or_default()
                 < 3
             {
                 inbox.configure_folders(context, 0x1i32);
             }
-            let dest_folder = context.sql.get_config(context, "configured_mvbox_folder");
+            let dest_folder = context
+                .sql
+                .get_raw_config(context, "configured_mvbox_folder");
 
             if let Some(dest_folder) = dest_folder {
                 let server_folder = msg.server_folder.as_ref().unwrap();
@@ -261,26 +264,18 @@ impl Job {
         if let Ok(mut msg) = Message::load_from_db(context, self.foreign_id) {
             if !msg.rfc724_mid.is_empty() {
                 /* eg. device messages have no Message-ID */
-                let mut delete_from_server = true;
-                if message::rfc724_mid_cnt(context, &msg.rfc724_mid) != 1 {
+                if message::rfc724_mid_cnt(context, &msg.rfc724_mid) > 1 {
                     info!(
                         context,
                         "The message is deleted from the server when all parts are deleted.",
                     );
-                    delete_from_server = false;
-                }
-                /* if this is the last existing part of the message, we delete the message from the server */
-                if delete_from_server {
-                    if !inbox.is_connected() {
-                        connect_to_inbox(context, &inbox);
-                        if !inbox.is_connected() {
-                            self.try_again_later(3i32, None);
-                            return;
-                        }
-                    }
+                } else {
+                    /* if this is the last existing part of the message,
+                    we delete the message from the server */
                     let mid = msg.rfc724_mid;
                     let server_folder = msg.server_folder.as_ref().unwrap();
-                    if 0 == inbox.delete_msg(context, &mid, server_folder, &mut msg.server_uid) {
+                    let res = inbox.delete_msg(context, &mid, server_folder, &mut msg.server_uid);
+                    if res == ImapResult::RetryLater {
                         self.try_again_later(-1i32, None);
                         return;
                     }
@@ -294,37 +289,23 @@ impl Job {
     fn do_DC_JOB_MARKSEEN_MSG_ON_IMAP(&mut self, context: &Context) {
         let inbox = context.inbox.read().unwrap();
 
-        if !inbox.is_connected() {
-            connect_to_inbox(context, &inbox);
-            if !inbox.is_connected() {
-                self.try_again_later(3i32, None);
-                return;
-            }
-        }
         if let Ok(msg) = Message::load_from_db(context, self.foreign_id) {
-            let server_folder = msg.server_folder.as_ref().unwrap();
-            match inbox.set_seen(context, server_folder, msg.server_uid) {
-                ImapResult::Failed => {}
+            let folder = msg.server_folder.as_ref().unwrap();
+            match inbox.set_seen(context, folder, msg.server_uid) {
                 ImapResult::RetryLater => {
                     self.try_again_later(3i32, None);
                 }
-                _ => {
+                ImapResult::AlreadyDone => {}
+                ImapResult::Success | ImapResult::Failed => {
+                    // XXX the message might just have been moved
+                    // we want to send out an MDN anyway
+                    // The job will not be retried so locally
+                    // there is no risk of double-sending MDNs.
                     if 0 != msg.param.get_int(Param::WantsMdn).unwrap_or_default()
-                        && 0 != context
-                            .sql
-                            .get_config_int(context, "mdns_enabled")
-                            .unwrap_or_else(|| 1)
+                        && context.get_config_bool(Config::MdnsEnabled)
                     {
-                        let folder = msg.server_folder.as_ref().unwrap();
-
-                        match inbox.set_mdnsent(context, folder, msg.server_uid) {
-                            ImapResult::RetryLater => {
-                                self.try_again_later(3i32, None);
-                            }
-                            ImapResult::Success => {
-                                send_mdn(context, msg.id);
-                            }
-                            ImapResult::Failed | ImapResult::AlreadyDone => {}
+                        if let Err(err) = send_mdn(context, msg.id) {
+                            warn!(context, "could not send out mdn for {}: {}", msg.id, err);
                         }
                     }
                 }
@@ -341,31 +322,26 @@ impl Job {
             .to_string();
         let uid = self.param.get_int(Param::ServerUid).unwrap_or_default() as u32;
         let inbox = context.inbox.read().unwrap();
-
-        if !inbox.is_connected() {
-            connect_to_inbox(context, &inbox);
-            if !inbox.is_connected() {
-                self.try_again_later(3, None);
-                return;
-            }
-        }
-        if inbox.set_seen(context, &folder, uid) == ImapResult::Failed {
+        if inbox.set_seen(context, &folder, uid) == ImapResult::RetryLater {
             self.try_again_later(3i32, None);
+            return;
         }
         if 0 != self.param.get_int(Param::AlsoMove).unwrap_or_default() {
             if context
                 .sql
-                .get_config_int(context, "folders_configured")
+                .get_raw_config_int(context, "folders_configured")
                 .unwrap_or_default()
                 < 3
             {
                 inbox.configure_folders(context, 0x1i32);
             }
-            let dest_folder = context.sql.get_config(context, "configured_mvbox_folder");
+            let dest_folder = context
+                .sql
+                .get_raw_config(context, "configured_mvbox_folder");
             if let Some(dest_folder) = dest_folder {
                 let mut dest_uid = 0;
                 if ImapResult::RetryLater
-                    == inbox.mv(context, folder, uid, dest_folder, &mut dest_uid)
+                    == inbox.mv(context, &folder, uid, &dest_folder, &mut dest_uid)
                 {
                     self.try_again_later(3, None);
                 }
@@ -392,12 +368,7 @@ pub fn perform_imap_fetch(context: &Context) {
     if 0 == connect_to_inbox(context, &inbox) {
         return;
     }
-    if context
-        .sql
-        .get_config_int(context, "inbox_watch")
-        .unwrap_or_else(|| 1)
-        == 0
-    {
+    if !context.get_config_bool(Config::InboxWatch) {
         info!(context, "INBOX-watch disabled.",);
         return;
     }
@@ -432,29 +403,23 @@ pub fn perform_imap_idle(context: &Context) {
 }
 
 pub fn perform_mvbox_fetch(context: &Context) {
-    let use_network = context
-        .sql
-        .get_config_int(context, "mvbox_watch")
-        .unwrap_or_else(|| 1);
+    let use_network = context.get_config_bool(Config::MvboxWatch);
 
     context
         .mvbox_thread
         .write()
         .unwrap()
-        .fetch(context, use_network == 1);
+        .fetch(context, use_network);
 }
 
 pub fn perform_mvbox_idle(context: &Context) {
-    let use_network = context
-        .sql
-        .get_config_int(context, "mvbox_watch")
-        .unwrap_or_else(|| 1);
+    let use_network = context.get_config_bool(Config::MvboxWatch);
 
     context
         .mvbox_thread
         .read()
         .unwrap()
-        .idle(context, use_network == 1);
+        .idle(context, use_network);
 }
 
 pub fn interrupt_mvbox_idle(context: &Context) {
@@ -462,29 +427,23 @@ pub fn interrupt_mvbox_idle(context: &Context) {
 }
 
 pub fn perform_sentbox_fetch(context: &Context) {
-    let use_network = context
-        .sql
-        .get_config_int(context, "sentbox_watch")
-        .unwrap_or_else(|| 1);
+    let use_network = context.get_config_bool(Config::SentboxWatch);
 
     context
         .sentbox_thread
         .write()
         .unwrap()
-        .fetch(context, use_network == 1);
+        .fetch(context, use_network);
 }
 
 pub fn perform_sentbox_idle(context: &Context) {
-    let use_network = context
-        .sql
-        .get_config_int(context, "sentbox_watch")
-        .unwrap_or_else(|| 1);
+    let use_network = context.get_config_bool(Config::SentboxWatch);
 
     context
         .sentbox_thread
         .read()
         .unwrap()
-        .idle(context, use_network == 1);
+        .idle(context, use_network);
 }
 
 pub fn interrupt_sentbox_idle(context: &Context) {
@@ -601,109 +560,108 @@ pub fn job_action_exists(context: &Context, action: Action) -> bool {
 
 /* special case for DC_JOB_SEND_MSG_TO_SMTP */
 #[allow(non_snake_case)]
-pub fn job_send_msg(context: &Context, msg_id: u32) -> libc::c_int {
-    let mut success = 0;
+pub fn job_send_msg(context: &Context, msg_id: u32) -> Result<(), Error> {
+    let mut mimefactory = MimeFactory::load_msg(context, msg_id)?;
 
-    /* load message data */
-    let mimefactory = MimeFactory::load_msg(context, msg_id);
-    if mimefactory.is_err() {
-        warn!(
-            context,
-            "Cannot load data to send, maybe the message is deleted in between.",
-        );
-    } else {
-        let mut mimefactory = mimefactory.unwrap();
-        // no redo, no IMAP. moreover, as the data does not exist, there is no need in calling dc_set_msg_failed()
-        if chat::msgtype_has_file(mimefactory.msg.type_0) {
-            let file_param = mimefactory
-                .msg
-                .param
-                .get(Param::File)
-                .map(|s| s.to_string());
-            if let Some(pathNfilename) = file_param {
-                if (mimefactory.msg.type_0 == Viewtype::Image
-                    || mimefactory.msg.type_0 == Viewtype::Gif)
-                    && !mimefactory.msg.param.exists(Param::Width)
-                {
-                    mimefactory.msg.param.set_int(Param::Width, 0);
-                    mimefactory.msg.param.set_int(Param::Height, 0);
-
-                    if let Ok(buf) = dc_read_file(context, pathNfilename) {
-                        if let Ok((width, height)) = dc_get_filemeta(&buf) {
-                            mimefactory.msg.param.set_int(Param::Width, width as i32);
-                            mimefactory.msg.param.set_int(Param::Height, height as i32);
-                        }
-                    }
-                    mimefactory.msg.save_param_to_disk(context);
-                }
-            }
-        }
-        /* create message */
-        if let Err(msg) = unsafe { mimefactory.render() } {
-            let e = msg.to_string();
-            message::set_msg_failed(context, msg_id, Some(e));
-        } else if 0
-            != mimefactory
-                .msg
-                .param
-                .get_int(Param::GuranteeE2ee)
-                .unwrap_or_default()
-            && !mimefactory.out_encrypted
-        {
-            /* unrecoverable */
-            warn!(
-                context,
-                "e2e encryption unavailable {} - {:?}",
-                msg_id,
-                mimefactory.msg.param.get_int(Param::GuranteeE2ee),
-            );
-            message::set_msg_failed(
-                context,
-                msg_id,
-                Some("End-to-end-encryption unavailable unexpectedly."),
-            );
-        } else {
-            if !vec_contains_lowercase(&mimefactory.recipients_addr, &mimefactory.from_addr) {
-                mimefactory.recipients_names.push("".to_string());
-                mimefactory
-                    .recipients_addr
-                    .push(mimefactory.from_addr.to_string());
-            }
-            if mimefactory.out_gossiped {
-                chat::set_gossiped_timestamp(context, mimefactory.msg.chat_id, time());
-            }
-            if 0 != mimefactory.out_last_added_location_id {
-                if let Err(err) =
-                    location::set_kml_sent_timestamp(context, mimefactory.msg.chat_id, time())
-                {
-                    error!(context, "Failed to set kml sent_timestamp: {:?}", err);
-                }
-                if !mimefactory.msg.hidden {
-                    if let Err(err) = location::set_msg_location_id(
-                        context,
-                        mimefactory.msg.id,
-                        mimefactory.out_last_added_location_id,
-                    ) {
-                        error!(context, "Failed to set msg_location_id: {:?}", err);
-                    }
-                }
-            }
-            if mimefactory.out_encrypted
-                && mimefactory
-                    .msg
-                    .param
-                    .get_int(Param::GuranteeE2ee)
-                    .unwrap_or_default()
-                    == 0
+    if chat::msgtype_has_file(mimefactory.msg.type_0) {
+        let file_param = mimefactory
+            .msg
+            .param
+            .get(Param::File)
+            .map(|s| s.to_string());
+        if let Some(pathNfilename) = file_param {
+            if (mimefactory.msg.type_0 == Viewtype::Image
+                || mimefactory.msg.type_0 == Viewtype::Gif)
+                && !mimefactory.msg.param.exists(Param::Width)
             {
-                mimefactory.msg.param.set_int(Param::GuranteeE2ee, 1);
+                mimefactory.msg.param.set_int(Param::Width, 0);
+                mimefactory.msg.param.set_int(Param::Height, 0);
+
+                if let Ok(buf) = dc_read_file(context, pathNfilename) {
+                    if let Ok((width, height)) = dc_get_filemeta(&buf) {
+                        mimefactory.msg.param.set_int(Param::Width, width as i32);
+                        mimefactory.msg.param.set_int(Param::Height, height as i32);
+                    }
+                }
                 mimefactory.msg.save_param_to_disk(context);
             }
-            success = add_smtp_job(context, Action::SendMsgToSmtp, &mut mimefactory);
         }
     }
 
-    success
+    /* create message */
+    if let Err(msg) = unsafe { mimefactory.render() } {
+        let e = msg.to_string();
+        message::set_msg_failed(context, msg_id, Some(e));
+        return Err(msg);
+    }
+    if 0 != mimefactory
+        .msg
+        .param
+        .get_int(Param::GuranteeE2ee)
+        .unwrap_or_default()
+        && !mimefactory.out_encrypted
+    {
+        /* unrecoverable */
+        message::set_msg_failed(
+            context,
+            msg_id,
+            Some("End-to-end-encryption unavailable unexpectedly."),
+        );
+        bail!(
+            "e2e encryption unavailable {} - {:?}",
+            msg_id,
+            mimefactory.msg.param.get_int(Param::GuranteeE2ee),
+        );
+    }
+    if context.get_config_bool(Config::BccSelf)
+        && !vec_contains_lowercase(&mimefactory.recipients_addr, &mimefactory.from_addr)
+    {
+        mimefactory.recipients_names.push("".to_string());
+        mimefactory
+            .recipients_addr
+            .push(mimefactory.from_addr.to_string());
+    }
+
+    if mimefactory.recipients_addr.is_empty() {
+        warn!(
+            context,
+            "message {} has no recipient, skipping smtp-send", msg_id
+        );
+        return Ok(());
+    }
+
+    if mimefactory.out_gossiped {
+        chat::set_gossiped_timestamp(context, mimefactory.msg.chat_id, time());
+    }
+    if 0 != mimefactory.out_last_added_location_id {
+        if let Err(err) = location::set_kml_sent_timestamp(context, mimefactory.msg.chat_id, time())
+        {
+            error!(context, "Failed to set kml sent_timestamp: {:?}", err);
+        }
+        if !mimefactory.msg.hidden {
+            if let Err(err) = location::set_msg_location_id(
+                context,
+                mimefactory.msg.id,
+                mimefactory.out_last_added_location_id,
+            ) {
+                error!(context, "Failed to set msg_location_id: {:?}", err);
+            }
+        }
+    }
+    if mimefactory.out_encrypted
+        && mimefactory
+            .msg
+            .param
+            .get_int(Param::GuranteeE2ee)
+            .unwrap_or_default()
+            == 0
+    {
+        mimefactory.msg.param.set_int(Param::GuranteeE2ee, 1);
+        mimefactory.msg.save_param_to_disk(context);
+    }
+    add_smtp_job(context, Action::SendMsgToSmtp, &mut mimefactory)?;
+
+    Ok(())
 }
 
 pub fn perform_imap_jobs(context: &Context) {
@@ -793,13 +751,13 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
         // - they can be re-executed one time AT_ONCE, but they are not save in the database for later execution
         if Action::ConfigureImap == job.action || Action::ImexImap == job.action {
             job_kill_action(context, job.action);
-            &context
+            context
                 .sentbox_thread
                 .clone()
                 .read()
                 .unwrap()
                 .suspend(context);
-            &context
+            context
                 .mvbox_thread
                 .clone()
                 .read()
@@ -924,8 +882,7 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
 #[allow(non_snake_case)]
 fn get_backoff_time_offset(c_tries: libc::c_int) -> i64 {
     // results in ~3 weeks for the last backoff timespan
-    let mut N = 2_i32.pow((c_tries - 1) as u32);
-    N = N * 60;
+    let N = 2_i32.pow((c_tries - 1) as u32) * 60;
     let mut rng = thread_rng();
     let n: i32 = rng.gen();
     let mut seconds = n % (N + 1);
@@ -947,7 +904,7 @@ fn suspend_smtp_thread(context: &Context, suspend: bool) {
     }
 }
 
-fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
+pub fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
     let ret_connected = dc_connect_to_configured_imap(context, inbox);
     if 0 != ret_connected {
         inbox.set_watch_folder("INBOX".into());
@@ -955,16 +912,20 @@ fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
     ret_connected
 }
 
-fn send_mdn(context: &Context, msg_id: u32) {
-    if let Ok(mut mimefactory) = MimeFactory::load_mdn(context, msg_id) {
-        if unsafe { mimefactory.render() }.is_ok() {
-            add_smtp_job(context, Action::SendMdn, &mut mimefactory);
-        }
-    }
+fn send_mdn(context: &Context, msg_id: u32) -> Result<(), Error> {
+    let mut mimefactory = MimeFactory::load_mdn(context, msg_id)?;
+    unsafe { mimefactory.render()? };
+    add_smtp_job(context, Action::SendMdn, &mut mimefactory)?;
+
+    Ok(())
 }
 
 #[allow(non_snake_case)]
-fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) -> libc::c_int {
+fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) -> Result<(), Error> {
+    ensure!(
+        !mimefactory.recipients_addr.is_empty(),
+        "no recipients for smtp job set"
+    );
     let mut param = Params::new();
     let bytes = unsafe {
         std::slice::from_raw_parts(
@@ -972,17 +933,7 @@ fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) ->
             (*mimefactory.out).len,
         )
     };
-    let bpath = match context.new_blob_file(&mimefactory.rfc724_mid, bytes) {
-        Ok(path) => path,
-        Err(err) => {
-            error!(
-                context,
-                "Could not write {} smtp-message, error {}", mimefactory.rfc724_mid, err
-            );
-            return 0;
-        }
-    };
-    info!(context, "add_smtp_job file written: {:?}", bpath);
+    let bpath = context.new_blob_file(&mimefactory.rfc724_mid, bytes)?;
     let recipients = mimefactory.recipients_addr.join("\x1e");
     param.set(Param::File, &bpath);
     param.set(Param::Recipients, &recipients);
@@ -997,7 +948,8 @@ fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) ->
         param,
         0,
     );
-    1
+
+    Ok(())
 }
 
 pub fn job_add(

src/job_thread.rs

@@ -116,14 +116,14 @@ impl JobThread {
         if ret_connected {
             if context
                 .sql
-                .get_config_int(context, "folders_configured")
+                .get_raw_config_int(context, "folders_configured")
                 .unwrap_or_default()
                 < 3
             {
                 self.imap.configure_folders(context, 0x1);
             }
 
-            if let Some(mvbox_name) = context.sql.get_config(context, self.folder_config_name) {
+            if let Some(mvbox_name) = context.sql.get_raw_config(context, self.folder_config_name) {
                 self.imap.set_watch_folder(mvbox_name);
             } else {
                 self.imap.disconnect(context);

src/key.rs

@@ -163,8 +163,8 @@ impl Key {
 
     pub fn to_bytes(&self) -> Vec<u8> {
         match self {
-            Key::Public(k) => k.to_bytes().unwrap(),
-            Key::Secret(k) => k.to_bytes().unwrap(),
+            Key::Public(k) => k.to_bytes().unwrap_or_default(),
+            Key::Secret(k) => k.to_bytes().unwrap_or_default(),
         }
     }
 
@@ -218,10 +218,10 @@ impl Key {
         let file_content = self.to_asc(None).into_bytes();
 
         if dc_write_file(context, &file, &file_content) {
-            return true;
+            true
         } else {
             error!(context, "Cannot write key to {}", file.as_ref().display());
-            return false;
+            false
         }
     }
 

src/location.rs

@@ -3,6 +3,7 @@ use quick_xml;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText};
 
 use crate::chat;
+use crate::config::Config;
 use crate::constants::*;
 use crate::context::*;
 use crate::dc_tools::*;
@@ -62,7 +63,7 @@ impl Kml {
 
     pub fn parse(context: &Context, content: impl AsRef<str>) -> Result<Self, Error> {
         ensure!(
-            content.as_ref().len() <= (1 * 1024 * 1024),
+            content.as_ref().len() <= (1024 * 1024),
             "A kml-files with {} bytes is larger than reasonably expected.",
             content.as_ref().len()
         );
@@ -218,7 +219,7 @@ pub fn send_locations_to_chat(context: &Context, chat_id: u32, seconds: i64) {
                 msg.text =
                     Some(context.stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0));
                 msg.param.set_int(Param::Cmd, 8);
-                chat::send_msg(context, chat_id, &mut msg).unwrap();
+                chat::send_msg(context, chat_id, &mut msg).unwrap_or_default();
             } else if 0 == seconds && is_sending_locations_before {
                 let stock_str =
                     context.stock_system_msg(StockMessage::MsgLocationDisabled, "", "", 0);
@@ -359,7 +360,7 @@ pub fn get_range(
 }
 
 fn is_marker(txt: &str) -> bool {
-    txt.len() == 1 && txt.chars().next().unwrap() != ' '
+    txt.len() == 1 && !txt.starts_with(' ')
 }
 
 pub fn delete_all(context: &Context) -> Result<(), Error> {
@@ -375,8 +376,7 @@ pub fn get_kml(context: &Context, chat_id: u32) -> Result<(String, u32), Error>
     let mut last_added_location_id = 0;
 
     let self_addr = context
-        .sql
-        .get_config(context, "configured_addr")
+        .get_config(Config::ConfiguredAddr)
         .unwrap_or_default();
 
     let (locations_send_begin, locations_send_until, locations_last_sent) = context.sql.query_row(
@@ -615,7 +615,7 @@ pub fn job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &Context, _job: &Job) {
 
         for (chat_id, mut msg) in msgs.into_iter() {
             // TODO: better error handling
-            chat::send_msg(context, chat_id as u32, &mut msg).unwrap();
+            chat::send_msg(context, chat_id as u32, &mut msg).unwrap_or_default();
         }
     }
     if 0 != continue_streaming {

src/login_param.rs

@@ -4,6 +4,22 @@ use std::fmt;
 use crate::context::Context;
 use crate::error::Error;
 
+#[derive(Copy, Clone, Debug, Display, FromPrimitive)]
+#[repr(i32)]
+#[strum(serialize_all = "snake_case")]
+pub enum CertificateChecks {
+    Automatic = 0,
+    Strict = 1,
+    AcceptInvalidHostnames = 2,
+    AcceptInvalidCertificates = 3,
+}
+
+impl Default for CertificateChecks {
+    fn default() -> Self {
+        Self::Automatic
+    }
+}
+
 #[derive(Default, Debug)]
 pub struct LoginParam {
     pub addr: String,
@@ -11,10 +27,14 @@ pub struct LoginParam {
     pub mail_user: String,
     pub mail_pw: String,
     pub mail_port: i32,
+    /// IMAP TLS options: whether to allow invalid certificates and/or invalid hostnames
+    pub imap_certificate_checks: CertificateChecks,
     pub send_server: String,
     pub send_user: String,
     pub send_pw: String,
     pub send_port: i32,
+    /// SMTP TLS options: whether to allow invalid certificates and/or invalid hostnames
+    pub smtp_certificate_checks: CertificateChecks,
     pub server_flags: i32,
 }
 
@@ -31,37 +51,53 @@ impl LoginParam {
 
         let key = format!("{}addr", prefix);
         let addr = sql
-            .get_config(context, key)
+            .get_raw_config(context, key)
             .unwrap_or_default()
             .trim()
             .to_string();
 
         let key = format!("{}mail_server", prefix);
-        let mail_server = sql.get_config(context, key).unwrap_or_default();
+        let mail_server = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}mail_port", prefix);
-        let mail_port = sql.get_config_int(context, key).unwrap_or_default();
+        let mail_port = sql.get_raw_config_int(context, key).unwrap_or_default();
 
         let key = format!("{}mail_user", prefix);
-        let mail_user = sql.get_config(context, key).unwrap_or_default();
+        let mail_user = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}mail_pw", prefix);
-        let mail_pw = sql.get_config(context, key).unwrap_or_default();
+        let mail_pw = sql.get_raw_config(context, key).unwrap_or_default();
+
+        let key = format!("{}imap_certificate_checks", prefix);
+        let imap_certificate_checks =
+            if let Some(certificate_checks) = sql.get_raw_config_int(context, key) {
+                num_traits::FromPrimitive::from_i32(certificate_checks).unwrap()
+            } else {
+                Default::default()
+            };
 
         let key = format!("{}send_server", prefix);
-        let send_server = sql.get_config(context, key).unwrap_or_default();
+        let send_server = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}send_port", prefix);
-        let send_port = sql.get_config_int(context, key).unwrap_or_default();
+        let send_port = sql.get_raw_config_int(context, key).unwrap_or_default();
 
         let key = format!("{}send_user", prefix);
-        let send_user = sql.get_config(context, key).unwrap_or_default();
+        let send_user = sql.get_raw_config(context, key).unwrap_or_default();
 
         let key = format!("{}send_pw", prefix);
-        let send_pw = sql.get_config(context, key).unwrap_or_default();
+        let send_pw = sql.get_raw_config(context, key).unwrap_or_default();
+
+        let key = format!("{}smtp_certificate_checks", prefix);
+        let smtp_certificate_checks =
+            if let Some(certificate_checks) = sql.get_raw_config_int(context, key) {
+                num_traits::FromPrimitive::from_i32(certificate_checks).unwrap()
+            } else {
+                Default::default()
+            };
 
         let key = format!("{}server_flags", prefix);
-        let server_flags = sql.get_config_int(context, key).unwrap_or_default();
+        let server_flags = sql.get_raw_config_int(context, key).unwrap_or_default();
 
         LoginParam {
             addr: addr.to_string(),
@@ -69,10 +105,12 @@ impl LoginParam {
             mail_user,
             mail_pw,
             mail_port,
+            imap_certificate_checks,
             send_server,
             send_user,
             send_pw,
             send_port,
+            smtp_certificate_checks,
             server_flags,
         }
     }
@@ -91,34 +129,40 @@ impl LoginParam {
         let sql = &context.sql;
 
         let key = format!("{}addr", prefix);
-        sql.set_config(context, key, Some(&self.addr))?;
+        sql.set_raw_config(context, key, Some(&self.addr))?;
 
         let key = format!("{}mail_server", prefix);
-        sql.set_config(context, key, Some(&self.mail_server))?;
+        sql.set_raw_config(context, key, Some(&self.mail_server))?;
 
         let key = format!("{}mail_port", prefix);
-        sql.set_config_int(context, key, self.mail_port)?;
+        sql.set_raw_config_int(context, key, self.mail_port)?;
 
         let key = format!("{}mail_user", prefix);
-        sql.set_config(context, key, Some(&self.mail_user))?;
+        sql.set_raw_config(context, key, Some(&self.mail_user))?;
 
         let key = format!("{}mail_pw", prefix);
-        sql.set_config(context, key, Some(&self.mail_pw))?;
+        sql.set_raw_config(context, key, Some(&self.mail_pw))?;
+
+        let key = format!("{}imap_certificate_checks", prefix);
+        sql.set_raw_config_int(context, key, self.imap_certificate_checks as i32)?;
 
         let key = format!("{}send_server", prefix);
-        sql.set_config(context, key, Some(&self.send_server))?;
+        sql.set_raw_config(context, key, Some(&self.send_server))?;
 
         let key = format!("{}send_port", prefix);
-        sql.set_config_int(context, key, self.send_port)?;
+        sql.set_raw_config_int(context, key, self.send_port)?;
 
         let key = format!("{}send_user", prefix);
-        sql.set_config(context, key, Some(&self.send_user))?;
+        sql.set_raw_config(context, key, Some(&self.send_user))?;
 
         let key = format!("{}send_pw", prefix);
-        sql.set_config(context, key, Some(&self.send_pw))?;
+        sql.set_raw_config(context, key, Some(&self.send_pw))?;
+
+        let key = format!("{}smtp_certificate_checks", prefix);
+        sql.set_raw_config_int(context, key, self.smtp_certificate_checks as i32)?;
 
         let key = format!("{}server_flags", prefix);
-        sql.set_config_int(context, key, self.server_flags)?;
+        sql.set_raw_config_int(context, key, self.server_flags)?;
 
         Ok(())
     }
@@ -133,16 +177,18 @@ impl fmt::Display for LoginParam {
 
         write!(
             f,
-            "{} {}:{}:{}:{} {}:{}:{}:{} {}",
+            "{} imap:{}:{}:{}:{}:cert_{} smtp:{}:{}:{}:{}:cert_{} {}",
             unset_empty(&self.addr),
             unset_empty(&self.mail_user),
             if !self.mail_pw.is_empty() { pw } else { unset },
             unset_empty(&self.mail_server),
             self.mail_port,
+            self.imap_certificate_checks,
             unset_empty(&self.send_user),
             if !self.send_pw.is_empty() { pw } else { unset },
             unset_empty(&self.send_server),
             self.send_port,
+            self.smtp_certificate_checks,
             flags_readable,
         )
     }
@@ -204,3 +250,41 @@ fn get_readable_flags(flags: i32) -> String {
 
     res
 }
+
+pub fn dc_build_tls(
+    certificate_checks: CertificateChecks,
+) -> Result<native_tls::TlsConnector, native_tls::Error> {
+    let mut tls_builder = native_tls::TlsConnector::builder();
+    match certificate_checks {
+        CertificateChecks::Automatic => {
+            // Same as AcceptInvalidCertificates for now.
+            // TODO: use provider database when it becomes available
+            tls_builder
+                .danger_accept_invalid_hostnames(true)
+                .danger_accept_invalid_certs(true)
+        }
+        CertificateChecks::Strict => &mut tls_builder,
+        CertificateChecks::AcceptInvalidHostnames => {
+            tls_builder.danger_accept_invalid_hostnames(true)
+        }
+        CertificateChecks::AcceptInvalidCertificates => tls_builder
+            .danger_accept_invalid_hostnames(true)
+            .danger_accept_invalid_certs(true),
+    }
+    .build()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_certificate_checks_display() {
+        use std::string::ToString;
+
+        assert_eq!(
+            "accept_invalid_hostnames".to_string(),
+            CertificateChecks::AcceptInvalidHostnames.to_string()
+        );
+    }
+}

src/message.rs

@@ -355,7 +355,7 @@ impl Message {
                     ) && buf_headerline == "-----BEGIN PGP MESSAGE-----"
                         && !buf_setupcodebegin.is_null()
                     {
-                        return Some(to_string(buf_setupcodebegin));
+                        return Some(to_string_lossy(buf_setupcodebegin));
                     }
                 }
             }
@@ -494,12 +494,10 @@ impl Lot {
                     } else {
                         self.text1 = None;
                     }
+                } else if let Some(contact) = contact {
+                    self.text1 = Some(contact.get_first_name().into());
                 } else {
-                    if let Some(contact) = contact {
-                        self.text1 = Some(contact.get_first_name().into());
-                    } else {
-                        self.text1 = None;
-                    }
+                    self.text1 = None;
                 }
                 self.text1_meaning = Meaning::Text1Username;
             }
@@ -526,7 +524,7 @@ pub fn get_msg_info(context: &Context, msg_id: u32) -> String {
         return ret;
     }
 
-    let msg = msg.unwrap();
+    let msg = msg.unwrap_or_default();
 
     let rawtxt: Option<String> = context.sql.query_get_value(
         context,
@@ -538,7 +536,7 @@ pub fn get_msg_info(context: &Context, msg_id: u32) -> String {
         ret += &format!("Cannot load message #{}.", msg_id as usize);
         return ret;
     }
-    let rawtxt = rawtxt.unwrap();
+    let rawtxt = rawtxt.unwrap_or_default();
     let rawtxt = dc_truncate(rawtxt.trim(), 100000, false);
 
     let fts = dc_timestamp_to_str(msg.get_timestamp());
@@ -618,9 +616,8 @@ pub fn get_msg_info(context: &Context, msg_id: u32) -> String {
     }
 
     ret += "\n";
-    match msg.param.get(Param::Error) {
-        Some(err) => ret += &format!("Error: {}", err),
-        _ => {}
+    if let Some(err) = msg.param.get(Param::Error) {
+        ret += &format!("Error: {}", err)
     }
 
     if let Some(path) = msg.get_file(context) {
@@ -688,7 +685,7 @@ pub fn get_mime_headers(context: &Context, msg_id: u32) -> Option<String> {
 }
 
 pub fn delete_msgs(context: &Context, msg_ids: &[u32]) {
-    for msg_id in msg_ids.into_iter() {
+    for msg_id in msg_ids.iter() {
         update_msg_chat_id(context, *msg_id, DC_CHAT_ID_TRASH);
         job_add(
             context,
@@ -728,7 +725,7 @@ pub fn markseen_msgs(context: &Context, msg_ids: &[u32]) -> bool {
         "SELECT m.state, c.blocked  FROM msgs m  LEFT JOIN chats c ON c.id=m.chat_id  WHERE m.id=? AND m.chat_id>9",
         |mut stmt, _| {
             let mut res = Vec::with_capacity(msg_ids.len());
-            for id in msg_ids.into_iter() {
+            for id in msg_ids.iter() {
                 let query_res = stmt.query_row(params![*id as i32], |row| {
                     Ok((row.get::<_, MessageState>(0)?, row.get::<_, Option<Blocked>>(1)?.unwrap_or_default()))
                 });
@@ -748,7 +745,7 @@ pub fn markseen_msgs(context: &Context, msg_ids: &[u32]) -> bool {
         return false;
     }
     let mut send_event = false;
-    let msgs = msgs.unwrap();
+    let msgs = msgs.unwrap_or_default();
 
     for (id, curr_state, curr_blocked) in msgs.into_iter() {
         if curr_blocked == Blocked::Not {
@@ -798,7 +795,7 @@ pub fn star_msgs(context: &Context, msg_ids: &[u32], star: bool) -> bool {
     context
         .sql
         .prepare("UPDATE msgs SET starred=? WHERE id=?;", |mut stmt, _| {
-            for msg_id in msg_ids.into_iter() {
+            for msg_id in msg_ids.iter() {
                 stmt.execute(params![star as i32, *msg_id as i32])?;
             }
             Ok(())
@@ -818,6 +815,7 @@ pub fn get_summarytext_by_raw(
     let prefix = match viewtype {
         Viewtype::Image => context.stock_str(StockMessage::Image).into_owned(),
         Viewtype::Gif => context.stock_str(StockMessage::Gif).into_owned(),
+        Viewtype::Sticker => context.stock_str(StockMessage::Sticker).into_owned(),
         Viewtype::Video => context.stock_str(StockMessage::Video).into_owned(),
         Viewtype::Voice => context.stock_str(StockMessage::VoiceMessage).into_owned(),
         Viewtype::Audio | Viewtype::File => {
@@ -836,7 +834,7 @@ pub fn get_summarytext_by_raw(
                 } else {
                     None
                 }
-                .unwrap_or("ErrFileName".to_string());
+                .unwrap_or_else(|| "ErrFileName".to_string());
 
                 let label = context.stock_str(if viewtype == Viewtype::Audio {
                     StockMessage::Audio
@@ -984,7 +982,7 @@ pub fn mdn_from_ext(
                 context.sql.execute(
                     "INSERT INTO msgs_mdns (msg_id, contact_id, timestamp_sent) VALUES (?, ?, ?);",
                     params![*ret_msg_id as i32, from_id as i32, timestamp_sent],
-                ).unwrap(); // TODO: better error handling
+                ).unwrap_or_default(); // TODO: better error handling
             }
 
             // Normal chat? that's quite easy.

src/mimefactory.rs

@@ -13,10 +13,11 @@ use mmime::mmapstring::*;
 use mmime::other::*;
 
 use crate::chat::{self, Chat};
+use crate::config::Config;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::{get_version_str, Context};
-use crate::dc_mimeparser::{mailmime_find_mailimf_fields, SystemMessage};
+use crate::dc_mimeparser::SystemMessage;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
 use crate::e2ee::*;
@@ -59,11 +60,13 @@ pub struct MimeFactory<'a> {
 
 impl<'a> MimeFactory<'a> {
     fn new(context: &'a Context, msg: Message) -> Self {
-        let cget = |context: &Context, name: &str| context.sql.get_config(context, name);
         MimeFactory {
-            from_addr: cget(&context, "configured_addr").unwrap_or_default(),
-            from_displayname: cget(&context, "displayname").unwrap_or_default(),
-            selfstatus: cget(&context, "selfstatus")
+            from_addr: context
+                .get_config(Config::ConfiguredAddr)
+                .unwrap_or_default(),
+            from_displayname: context.get_config(Config::Displayname).unwrap_or_default(),
+            selfstatus: context
+                .get_config(Config::Selfstatus)
                 .unwrap_or_else(|| context.stock_str(StockMessage::StatusLine).to_string()),
             recipients_names: Vec::with_capacity(5),
             recipients_addr: Vec::with_capacity(5),
@@ -106,15 +109,10 @@ impl<'a> MimeFactory<'a> {
     }
 
     pub fn load_mdn(context: &'a Context, msg_id: u32) -> Result<MimeFactory, Error> {
-        if 0 == context
-            .sql
-            .get_config_int(context, "mdns_enabled")
-            .unwrap_or_else(|| 1)
-        {
-            // MDNs not enabled - check this is late, in the job. the use may have changed its
-            // choice while offline ...
-
-            bail!("MDNs disabled ")
+        if !context.get_config_bool(Config::MdnsEnabled) {
+            // MDNs not enabled - check this is late, in the job. the
+            // user may have changed its choice while offline ...
+            bail!("MDNs meanwhile disabled")
         }
 
         let msg = Message::load_from_db(context, msg_id)?;
@@ -141,52 +139,35 @@ impl<'a> MimeFactory<'a> {
     }
 
     /*******************************************************************************
-     * Render
+     * Render a basic email
      ******************************************************************************/
-    // restrict unsafe to parts, introduce wrapmime helpers where appropriate
+    // XXX restrict unsafe to parts, introduce wrapmime helpers where appropriate
     pub unsafe fn render(&mut self) -> Result<(), Error> {
         if self.loaded == Loaded::Nothing || !self.out.is_null() {
             bail!("Invalid use of mimefactory-object.");
         }
         let context = &self.context;
+        let from = wrapmime::new_mailbox_list(&self.from_displayname, &self.from_addr);
 
-        /* create basic mail
-         *************************************************************************/
-
-        let from: *mut mailimf_mailbox_list = mailimf_mailbox_list_new_empty();
-        mailimf_mailbox_list_add(
-            from,
-            mailimf_mailbox_new(
-                if !self.from_displayname.is_empty() {
-                    dc_encode_header_words(&self.from_displayname).strdup()
-                } else {
-                    ptr::null_mut()
-                },
-                self.from_addr.strdup(),
-            ),
-        );
-        let mut to: *mut mailimf_address_list = ptr::null_mut();
-        if !self.recipients_names.is_empty() && !self.recipients_addr.is_empty() {
-            to = mailimf_address_list_new_empty();
-            let name_iter = self.recipients_names.iter();
-            let addr_iter = self.recipients_addr.iter();
-            for (name, addr) in name_iter.zip(addr_iter) {
-                mailimf_address_list_add(
-                    to,
-                    mailimf_address_new(
-                        MAILIMF_ADDRESS_MAILBOX as libc::c_int,
-                        mailimf_mailbox_new(
-                            if !name.is_empty() {
-                                dc_encode_header_words(&name).strdup()
-                            } else {
-                                ptr::null_mut()
-                            },
-                            addr.strdup(),
-                        ),
-                        ptr::null_mut(),
+        let to = mailimf_address_list_new_empty();
+        let name_iter = self.recipients_names.iter();
+        let addr_iter = self.recipients_addr.iter();
+        for (name, addr) in name_iter.zip(addr_iter) {
+            mailimf_address_list_add(
+                to,
+                mailimf_address_new(
+                    MAILIMF_ADDRESS_MAILBOX as libc::c_int,
+                    mailimf_mailbox_new(
+                        if !name.is_empty() {
+                            dc_encode_header_words(&name).strdup()
+                        } else {
+                            ptr::null_mut()
+                        },
+                        addr.strdup(),
                     ),
-                );
-            }
+                    ptr::null_mut(),
+                ),
+            );
         }
         let references_list = if !self.references.is_empty() {
             dc_str_to_clist(&self.references, " ")
@@ -198,6 +179,7 @@ impl<'a> MimeFactory<'a> {
         } else {
             ptr::null_mut()
         };
+
         let imf_fields = mailimf_fields_new_with_data_all(
             mailimf_get_date(self.timestamp as i64),
             from,
@@ -402,15 +384,8 @@ impl<'a> MimeFactory<'a> {
                                     &fingerprint,
                                 );
                             }
-                            match msg.param.get(Param::Arg4) {
-                                Some(id) => {
-                                    wrapmime::new_custom_field(
-                                        imf_fields,
-                                        "Secure-Join-Group",
-                                        &id,
-                                    );
-                                }
-                                None => {}
+                            if let Some(id) = msg.param.get(Param::Arg4) {
+                                wrapmime::new_custom_field(imf_fields, "Secure-Join-Group", &id);
                             };
                         }
                     }
@@ -435,6 +410,10 @@ impl<'a> MimeFactory<'a> {
                     }
                 }
 
+                if self.msg.type_0 == Viewtype::Sticker {
+                    wrapmime::new_custom_field(imf_fields, "Chat-Content", "sticker");
+                }
+
                 if self.msg.type_0 == Viewtype::Voice
                     || self.msg.type_0 == Viewtype::Audio
                     || self.msg.type_0 == Viewtype::Video
@@ -594,7 +573,6 @@ impl<'a> MimeFactory<'a> {
                 wrapmime::set_body_text(mach_mime_part, &message_text2)?;
                 mailmime_add_part(multipart, mach_mime_part);
                 force_plaintext = DC_FP_NO_AUTOCRYPT_HEADER;
-                info!(context, "sending MDM {:?}", message_text2);
                 /* currently, we do not send MDNs encrypted:
                 - in a multi-device-setup that is not set up properly, MDNs would disturb the communication as they
                   are send automatically which may lead to spreading outdated Autocrypt headers.
@@ -645,7 +623,7 @@ impl<'a> MimeFactory<'a> {
         );
 
         /*just a pointer into mailmime structure, must not be freed*/
-        let imffields_unprotected = mailmime_find_mailimf_fields(message);
+        let imffields_unprotected = wrapmime::mailmime_find_mailimf_fields(message);
         ensure!(
             !imffields_unprotected.is_null(),
             "could not find mime fields"
@@ -657,17 +635,18 @@ impl<'a> MimeFactory<'a> {
             let aheader = encrypt_helper.get_aheader().to_string();
             wrapmime::new_custom_field(imffields_unprotected, "Autocrypt", &aheader);
         }
-        let mut finalized = false;
-        if force_plaintext == 0 {
-            finalized = encrypt_helper.try_encrypt(
+        let finalized = if force_plaintext == 0 {
+            encrypt_helper.try_encrypt(
                 self,
                 e2ee_guaranteed,
                 min_verified,
                 do_gossip,
                 message,
                 imffields_unprotected,
-            )?;
-        }
+            )?
+        } else {
+            false
+        };
         if !finalized {
             self.finalize_mime_message(message, false, false)?;
         }
@@ -692,31 +671,28 @@ impl<'a> MimeFactory<'a> {
                 .push(factory.from_displayname.to_string());
             factory.recipients_addr.push(factory.from_addr.to_string());
         } else {
-            context
-                .sql
-                .query_map(
-                    "SELECT c.authname, c.addr  \
-                     FROM chats_contacts cc  \
-                     LEFT JOIN contacts c ON cc.contact_id=c.id  \
-                     WHERE cc.chat_id=? AND cc.contact_id>9;",
-                    params![factory.msg.chat_id as i32],
-                    |row| {
-                        let authname: String = row.get(0)?;
-                        let addr: String = row.get(1)?;
-                        Ok((authname, addr))
-                    },
-                    |rows| {
-                        for row in rows {
-                            let (authname, addr) = row?;
-                            if !vec_contains_lowercase(&factory.recipients_addr, &addr) {
-                                factory.recipients_addr.push(addr);
-                                factory.recipients_names.push(authname);
-                            }
+            context.sql.query_map(
+                "SELECT c.authname, c.addr  \
+                 FROM chats_contacts cc  \
+                 LEFT JOIN contacts c ON cc.contact_id=c.id  \
+                 WHERE cc.chat_id=? AND cc.contact_id>9;",
+                params![factory.msg.chat_id as i32],
+                |row| {
+                    let authname: String = row.get(0)?;
+                    let addr: String = row.get(1)?;
+                    Ok((authname, addr))
+                },
+                |rows| {
+                    for row in rows {
+                        let (authname, addr) = row?;
+                        if !vec_contains_lowercase(&factory.recipients_addr, &addr) {
+                            factory.recipients_addr.push(addr);
+                            factory.recipients_names.push(authname);
                         }
-                        Ok(())
-                    },
-                )
-                .unwrap();
+                    }
+                    Ok(())
+                },
+            )?;
 
             let command = factory.msg.param.get_cmd();
             let msg = &factory.msg;
@@ -726,8 +702,7 @@ impl<'a> MimeFactory<'a> {
                 let email_to_remove = msg.param.get(Param::Arg).unwrap_or_default();
 
                 let self_addr = context
-                    .sql
-                    .get_config(context, "configured_addr")
+                    .get_config(Config::ConfiguredAddr)
                     .unwrap_or_default();
 
                 if !email_to_remove.is_empty() && email_to_remove != self_addr {
@@ -739,10 +714,7 @@ impl<'a> MimeFactory<'a> {
             }
             if command != SystemMessage::AutocryptSetupMessage
                 && command != SystemMessage::SecurejoinMessage
-                && 0 != context
-                    .sql
-                    .get_config_int(context, "mdns_enabled")
-                    .unwrap_or_else(|| 1)
+                && context.get_config_bool(Config::MdnsEnabled)
             {
                 factory.req_mdn = true;
             }
@@ -923,15 +895,13 @@ fn build_body_file(
         wrapmime::append_ct_param(content, "name", &filename_encoded)?;
 
         let mime_sub = mailmime_new_empty(content, mime_fields);
-        let abs_path = dc_get_abs_path(context, path_filename)
-            .to_c_string()
-            .unwrap();
+        let abs_path = dc_get_abs_path(context, path_filename).to_c_string()?;
         mailmime_set_body_file(mime_sub, dc_strdup(abs_path.as_ptr()));
         Ok((mime_sub, filename_to_send))
     }
 }
 
-pub(crate) fn vec_contains_lowercase(vec: &Vec<String>, part: &str) -> bool {
+pub(crate) fn vec_contains_lowercase(vec: &[String], part: &str) -> bool {
     let partlc = part.to_lowercase();
     for cur in vec.iter() {
         if cur.to_lowercase() == partlc {

src/oauth2.rs

@@ -50,7 +50,7 @@ pub fn dc_get_oauth2_url(
     if let Some(oauth2) = Oauth2::from_address(addr) {
         if context
             .sql
-            .set_config(
+            .set_raw_config(
                 context,
                 "oauth2_pending_redirect_uri",
                 Some(redirect_uri.as_ref()),
@@ -82,17 +82,17 @@ pub fn dc_get_oauth2_access_token(
 
         // read generated token
         if !regenerate && !is_expired(context) {
-            let access_token = context.sql.get_config(context, "oauth2_access_token");
+            let access_token = context.sql.get_raw_config(context, "oauth2_access_token");
             if access_token.is_some() {
                 // success
                 return access_token;
             }
         }
 
-        let refresh_token = context.sql.get_config(context, "oauth2_refresh_token");
+        let refresh_token = context.sql.get_raw_config(context, "oauth2_refresh_token");
         let refresh_token_for = context
             .sql
-            .get_config(context, "oauth2_refresh_token_for")
+            .get_raw_config(context, "oauth2_refresh_token_for")
             .unwrap_or_else(|| "unset".into());
 
         let (redirect_uri, token_url, update_redirect_uri_on_success) =
@@ -101,7 +101,7 @@ pub fn dc_get_oauth2_access_token(
                 (
                     context
                         .sql
-                        .get_config(context, "oauth2_pending_redirect_uri")
+                        .get_raw_config(context, "oauth2_pending_redirect_uri")
                         .unwrap_or_else(|| "unset".into()),
                     oauth2.init_token,
                     true,
@@ -114,7 +114,7 @@ pub fn dc_get_oauth2_access_token(
                 (
                     context
                         .sql
-                        .get_config(context, "oauth2_redirect_uri")
+                        .get_raw_config(context, "oauth2_redirect_uri")
                         .unwrap_or_else(|| "unset".into()),
                     oauth2.refresh_token,
                     false,
@@ -159,11 +159,11 @@ pub fn dc_get_oauth2_access_token(
         if let Some(ref token) = response.refresh_token {
             context
                 .sql
-                .set_config(context, "oauth2_refresh_token", Some(token))
+                .set_raw_config(context, "oauth2_refresh_token", Some(token))
                 .ok();
             context
                 .sql
-                .set_config(context, "oauth2_refresh_token_for", Some(code.as_ref()))
+                .set_raw_config(context, "oauth2_refresh_token_for", Some(code.as_ref()))
                 .ok();
         }
 
@@ -172,7 +172,7 @@ pub fn dc_get_oauth2_access_token(
         if let Some(ref token) = response.access_token {
             context
                 .sql
-                .set_config(context, "oauth2_access_token", Some(token))
+                .set_raw_config(context, "oauth2_access_token", Some(token))
                 .ok();
             let expires_in = response
                 .expires_in
@@ -181,13 +181,13 @@ pub fn dc_get_oauth2_access_token(
                 .unwrap_or_else(|| 0);
             context
                 .sql
-                .set_config_int64(context, "oauth2_timestamp_expires", expires_in)
+                .set_raw_config_int64(context, "oauth2_timestamp_expires", expires_in)
                 .ok();
 
             if update_redirect_uri_on_success {
                 context
                     .sql
-                    .set_config(context, "oauth2_redirect_uri", Some(redirect_uri.as_ref()))
+                    .set_raw_config(context, "oauth2_redirect_uri", Some(redirect_uri.as_ref()))
                     .ok();
             }
         } else {
@@ -207,14 +207,8 @@ pub fn dc_get_oauth2_addr(
     addr: impl AsRef<str>,
     code: impl AsRef<str>,
 ) -> Option<String> {
-    let oauth2 = Oauth2::from_address(addr.as_ref());
-    if oauth2.is_none() {
-        return None;
-    }
-    let oauth2 = oauth2.unwrap();
-    if oauth2.get_userinfo.is_none() {
-        return None;
-    }
+    let oauth2 = Oauth2::from_address(addr.as_ref())?;
+    oauth2.get_userinfo?;
 
     if let Some(access_token) =
         dc_get_oauth2_access_token(context, addr.as_ref(), code.as_ref(), false)
@@ -299,7 +293,7 @@ impl Oauth2 {
 fn is_expired(context: &Context) -> bool {
     let expire_timestamp = context
         .sql
-        .get_config_int64(context, "oauth2_timestamp_expires")
+        .get_raw_config_int64(context, "oauth2_timestamp_expires")
         .unwrap_or_default();
 
     if expire_timestamp <= 0 {

src/param.rs

@@ -12,65 +12,65 @@ use crate::error;
 #[repr(u8)]
 pub enum Param {
     /// For messages and jobs
-    File = 'f' as u8,
+    File = b'f',
     /// For Messages
-    Width = 'w' as u8,
+    Width = b'w',
     /// For Messages
-    Height = 'h' as u8,
+    Height = b'h',
     /// For Messages
-    Duration = 'd' as u8,
+    Duration = b'd',
     /// For Messages
-    MimeType = 'm' as u8,
+    MimeType = b'm',
     /// For Messages: message is encryoted, outgoing: guarantee E2EE or the message is not send
-    GuranteeE2ee = 'c' as u8,
+    GuranteeE2ee = b'c',
     /// For Messages: decrypted with validation errors or without mutual set, if neither
     /// 'c' nor 'e' are preset, the messages is only transport encrypted.
-    ErroneousE2ee = 'e' as u8,
+    ErroneousE2ee = b'e',
     /// For Messages: force unencrypted message, either `ForcePlaintext::AddAutocryptHeader` (1),
     /// `ForcePlaintext::NoAutocryptHeader` (2) or 0.
-    ForcePlaintext = 'u' as u8,
+    ForcePlaintext = b'u',
     /// For Messages
-    WantsMdn = 'r' as u8,
+    WantsMdn = b'r',
     /// For Messages
-    Forwarded = 'a' as u8,
+    Forwarded = b'a',
     /// For Messages
-    Cmd = 'S' as u8,
+    Cmd = b'S',
     /// For Messages
-    Arg = 'E' as u8,
+    Arg = b'E',
     /// For Messages
-    Arg2 = 'F' as u8,
+    Arg2 = b'F',
     /// For Messages
-    Arg3 = 'G' as u8,
+    Arg3 = b'G',
     /// For Messages
-    Arg4 = 'H' as u8,
+    Arg4 = b'H',
     /// For Messages
-    Error = 'L' as u8,
+    Error = b'L',
     /// For Messages: space-separated list of messaged IDs of forwarded copies.
-    PrepForwards = 'P' as u8,
+    PrepForwards = b'P',
     /// For Jobs
-    SetLatitude = 'l' as u8,
+    SetLatitude = b'l',
     /// For Jobs
-    SetLongitude = 'n' as u8,
+    SetLongitude = b'n',
     /// For Jobs
-    ServerFolder = 'Z' as u8,
+    ServerFolder = b'Z',
     /// For Jobs
-    ServerUid = 'z' as u8,
+    ServerUid = b'z',
     /// For Jobs
-    AlsoMove = 'M' as u8,
+    AlsoMove = b'M',
     /// For Jobs: space-separated list of message recipients
-    Recipients = 'R' as u8,
+    Recipients = b'R',
     // For Groups
-    Unpromoted = 'U' as u8,
+    Unpromoted = b'U',
     // For Groups and Contacts
-    ProfileImage = 'i' as u8,
+    ProfileImage = b'i',
     // For Chats
-    Selftalk = 'K' as u8,
+    Selftalk = b'K',
     // For QR
-    Auth = 's' as u8,
+    Auth = b's',
     // For QR
-    GroupId = 'x' as u8,
+    GroupId = b'x',
     // For QR
-    GroupName = 'g' as u8,
+    GroupName = b'g',
 }
 
 /// Possible values for `Param::ForcePlaintext`.
@@ -122,8 +122,8 @@ impl str::FromStr for Params {
             ensure!(key.is_some(), "Missing key");
             ensure!(value.is_some(), "Missing value");
 
-            let key = key.unwrap().trim();
-            let value = value.unwrap().trim();
+            let key = key.unwrap_or_default().trim();
+            let value = value.unwrap_or_default().trim();
 
             if let Some(key) = Param::from_u8(key.as_bytes()[0]) {
                 inner.insert(key, value.to_string());

src/peerstate.rs

@@ -400,7 +400,8 @@ impl<'a> Peerstate<'a> {
                     &self.verified_key_fingerprint,
                     &self.addr,
                 ],
-            )?
+            )?;
+            reset_gossiped_timestamp(self.context, 0);
         } else if self.to_save == Some(ToSave::Timestamps) {
             sql::execute(
                 self.context,
@@ -416,10 +417,6 @@ impl<'a> Peerstate<'a> {
             )?;
         }
 
-        if self.to_save == Some(ToSave::All) || create {
-            reset_gossiped_timestamp(self.context, 0);
-        }
-
         Ok(())
     }
 
@@ -475,7 +472,7 @@ mod tests {
             "failed to save to db"
         );
 
-        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr.into())
+        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr)
             .expect("failed to load peerstate from db");
 
         // clear to_save, as that is not persissted
@@ -487,6 +484,44 @@ mod tests {
         assert_eq!(peerstate, peerstate_new2);
     }
 
+    #[test]
+    fn test_peerstate_double_create() {
+        let ctx = crate::test_utils::dummy_context();
+        let addr = "hello@mail.com";
+
+        let pub_key = crate::key::Key::from_base64(
+            include_str!("../test-data/key/public.asc"),
+            KeyType::Public,
+        )
+        .unwrap();
+
+        let peerstate = Peerstate {
+            context: &ctx.ctx,
+            addr: Some(addr.into()),
+            last_seen: 10,
+            last_seen_autocrypt: 11,
+            prefer_encrypt: EncryptPreference::Mutual,
+            public_key: Some(pub_key.clone()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
+            gossip_key: None,
+            gossip_timestamp: 12,
+            gossip_key_fingerprint: None,
+            verified_key: None,
+            verified_key_fingerprint: None,
+            to_save: Some(ToSave::All),
+            degrade_event: None,
+        };
+
+        assert!(
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
+            "failed to save"
+        );
+        assert!(
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
+            "double-call with create failed"
+        );
+    }
+
     #[test]
     fn test_peerstate_with_empty_gossip_key_save_to_db() {
         let ctx = crate::test_utils::dummy_context();
@@ -520,7 +555,7 @@ mod tests {
             "failed to save"
         );
 
-        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr.into())
+        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr)
             .expect("failed to load peerstate from db");
 
         // clear to_save, as that is not persissted

src/pgp.rs

@@ -43,7 +43,7 @@ pub unsafe fn dc_split_armored_data(
     if !buf.is_null() {
         dc_remove_cr_chars(buf);
         while 0 != *p1 {
-            if *p1 as libc::c_int == '\n' as i32 {
+            if i32::from(*p1) == '\n' as i32 {
                 *line.offset(line_chars as isize) = 0i32 as libc::c_char;
                 if headerline.is_null() {
                     dc_trim(line);
@@ -69,7 +69,7 @@ pub unsafe fn dc_split_armored_data(
                 } else {
                     p2 = strchr(line, ':' as i32);
                     if p2.is_null() {
-                        *line.offset(line_chars as isize) = '\n' as i32 as libc::c_char;
+                        *line.add(line_chars) = '\n' as i32 as libc::c_char;
                         base64 = line;
                         break;
                     } else {
@@ -189,7 +189,7 @@ pub fn dc_pgp_pk_encrypt(
     let lit_msg = Message::new_literal_bytes("", plain);
     let pkeys: Vec<&SignedPublicKey> = public_keys_for_encryption
         .keys()
-        .into_iter()
+        .iter()
         .filter_map(|key| {
             let k: &Key = &key;
             k.try_into().ok()

src/securejoin.rs

@@ -3,7 +3,6 @@ use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};
 use crate::aheader::EncryptPreference;
 use crate::chat::{self, Chat};
 use crate::config::*;
-use crate::configure::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
@@ -82,10 +81,7 @@ pub fn dc_get_securejoin_qr(context: &Context, group_chat_id: u32) -> Option<Str
         }
     };
 
-    let self_name = context
-        .sql
-        .get_config(context, "displayname")
-        .unwrap_or_default();
+    let self_name = context.get_config(Config::Displayname).unwrap_or_default();
 
     fingerprint = match get_self_fingerprint(context) {
         Some(fp) => fp,
@@ -160,7 +156,7 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
             bob.qr_scan = None;
 
             if ongoing_allocated {
-                dc_free_ongoing(context);
+                context.free_ongoing();
             }
             ret_chat_id as u32
         };
@@ -173,7 +169,7 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
 
     info!(context, "Requesting secure-join ...",);
     ensure_secret_key_exists(context).ok();
-    if !dc_alloc_ongoing(context) {
+    if !context.alloc_ongoing() {
         return cleanup(&context, contact_chat_id, false, join_vg);
     }
     let qr_scan = check_qr(context, &qr);
@@ -187,7 +183,7 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
         error!(context, "Unknown contact.",);
         return cleanup(&context, contact_chat_id, true, join_vg);
     }
-    if check_exit(context) {
+    if context.shall_stop_ongoing() {
         return cleanup(&context, contact_chat_id, true, join_vg);
     }
     join_vg = qr_scan.get_state() == LotState::QrAskVerifyGroup;
@@ -213,7 +209,7 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
         info!(context, "Taking protocol shortcut.");
         context.bob.write().unwrap().expects = DC_VC_CONTACT_CONFIRM;
         joiner_progress!(context, chat_id_2_contact_id(context, contact_chat_id), 400);
-        let own_fingerprint = get_self_fingerprint(context).unwrap();
+        let own_fingerprint = get_self_fingerprint(context).unwrap_or_default();
         send_handshake_msg(
             context,
             contact_chat_id,
@@ -243,21 +239,12 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
     }
 
     // Bob -> Alice
-    while !check_exit(&context) {
+    while !context.shall_stop_ongoing() {
         std::thread::sleep(std::time::Duration::new(0, 3_000_000));
     }
     cleanup(&context, contact_chat_id, true, join_vg)
 }
 
-fn check_exit(context: &Context) -> bool {
-    context
-        .running_state
-        .clone()
-        .read()
-        .unwrap()
-        .shall_stop_ongoing
-}
-
 fn send_handshake_msg(
     context: &Context,
     contact_chat_id: u32,
@@ -294,7 +281,7 @@ fn send_handshake_msg(
         msg.param.set_int(Param::GuranteeE2ee, 1);
     }
     // TODO. handle cleanup on error
-    chat::send_msg(context, contact_chat_id, &mut msg).unwrap();
+    chat::send_msg(context, contact_chat_id, &mut msg).unwrap_or_default();
 }
 
 fn chat_id_2_contact_id(context: &Context, contact_chat_id: u32) -> u32 {
@@ -639,7 +626,7 @@ pub fn handle_securejoin_handshake(
 
 fn end_bobs_joining(context: &Context, status: libc::c_int) {
     context.bob.write().unwrap().status = status;
-    dc_stop_ongoing_process(context);
+    context.stop_ongoing();
 }
 
 fn secure_connection_established(context: &Context, contact_chat_id: u32) {
@@ -678,7 +665,9 @@ fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Res
         if peerstate.set_verified(1, fingerprint.as_ref(), 2) {
             peerstate.prefer_encrypt = EncryptPreference::Mutual;
             peerstate.to_save = Some(ToSave::All);
-            peerstate.save_to_db(&context.sql, false).unwrap();
+            peerstate
+                .save_to_db(&context.sql, false)
+                .unwrap_or_default();
             return Ok(());
         }
     }
@@ -696,7 +685,7 @@ fn encrypted_and_signed(mimeparser: &MimeParser, expected_fingerprint: impl AsRe
     if !mimeparser.encrypted {
         warn!(mimeparser.context, "Message not encrypted.",);
         false
-    } else if mimeparser.signatures.len() <= 0 {
+    } else if mimeparser.signatures.is_empty() {
         warn!(mimeparser.context, "Message not signed.",);
         false
     } else if expected_fingerprint.as_ref().is_empty() {

src/smtp.rs

@@ -3,8 +3,9 @@ use lettre::*;
 
 use crate::constants::*;
 use crate::context::Context;
+use crate::error::Error;
 use crate::events::Event;
-use crate::login_param::LoginParam;
+use crate::login_param::{dc_build_tls, LoginParam};
 use crate::oauth2::*;
 
 #[derive(DebugStub)]
@@ -14,7 +15,6 @@ pub struct Smtp {
     transport_connected: bool,
     /// Email address we are sending from.
     from: Option<EmailAddress>,
-    pub error: Option<String>,
 }
 
 impl Smtp {
@@ -24,7 +24,6 @@ impl Smtp {
             transport: None,
             transport_connected: false,
             from: None,
-            error: None,
         }
     }
 
@@ -69,14 +68,7 @@ impl Smtp {
         let domain = &lp.send_server;
         let port = lp.send_port as u16;
 
-        let tls = native_tls::TlsConnector::builder()
-            // see also: https://github.com/deltachat/deltachat-core-rust/issues/203
-            .danger_accept_invalid_hostnames(true)
-            .danger_accept_invalid_certs(true)
-            .min_protocol_version(Some(DEFAULT_TLS_PROTOCOLS[0]))
-            .build()
-            .unwrap();
-
+        let tls = dc_build_tls(lp.smtp_certificate_checks).unwrap();
         let tls_parameters = ClientTlsParameters::new(domain.to_string(), tls);
 
         let creds = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
@@ -89,7 +81,10 @@ impl Smtp {
             }
             let user = &lp.send_user;
 
-            lettre::smtp::authentication::Credentials::new(user.to_string(), access_token.unwrap())
+            lettre::smtp::authentication::Credentials::new(
+                user.to_string(),
+                access_token.unwrap_or_default(),
+            )
         } else {
             // plain
             let user = lp.send_user.clone();
@@ -125,37 +120,50 @@ impl Smtp {
         }
     }
 
+    /// SMTP-Send a prepared mail to recipients.
+    /// returns boolean whether send was successful.
     pub fn send<'a>(
         &mut self,
         context: &Context,
         recipients: Vec<EmailAddress>,
-        body: Vec<u8>,
-    ) -> usize {
+        message: Vec<u8>,
+    ) -> Result<(), Error> {
+        let message_len = message.len();
+
+        let recipients_display = recipients
+            .iter()
+            .map(|x| format!("{}", x))
+            .collect::<Vec<String>>()
+            .join(",");
+
         if let Some(ref mut transport) = self.transport {
-            let envelope = Envelope::new(self.from.clone(), recipients).expect("invalid envelope");
+            let envelope = Envelope::new(self.from.clone(), recipients);
+            ensure!(envelope.is_ok(), "internal smtp-message construction fail");
+            let envelope = envelope.unwrap();
             let mail = SendableEmail::new(
                 envelope,
                 "mail-id".into(), // TODO: random id
-                body,
+                message,
             );
 
             match transport.send(mail) {
                 Ok(_) => {
-                    context.call_cb(Event::SmtpMessageSent(
-                        "Message was sent to SMTP server".into(),
-                    ));
+                    context.call_cb(Event::SmtpMessageSent(format!(
+                        "Message len={} was smtp-sent to {}",
+                        message_len, recipients_display
+                    )));
                     self.transport_connected = true;
-                    1
+                    Ok(())
                 }
                 Err(err) => {
-                    warn!(context, "SMTP failed to send message: {}", err);
-                    self.error = Some(format!("{}", err));
-                    0
+                    bail!("SMTP failed len={}: error: {}", message_len, err);
                 }
             }
         } else {
-            // TODO: log error
-            0
+            bail!(
+                "uh? SMTP has no transport,  failed to send to {:?}",
+                recipients_display
+            );
         }
     }
 }

src/sql.rs

@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 use std::sync::{Arc, RwLock};
+use std::time::Duration;
 
 use rusqlite::{Connection, OpenFlags, Statement, NO_PARAMS};
 use thread_local_object::ThreadLocal;
@@ -68,6 +69,16 @@ impl Sql {
         let res = match &*self.pool.read().unwrap() {
             Some(pool) => {
                 let conn = pool.get()?;
+
+                // Only one process can make changes to the database at one time.
+                // busy_timeout defines, that if a seconds process wants write access,
+                // this second process will wait some milliseconds
+                // and try over until it gets write access or the given timeout is elapsed.
+                // If the second process does not get write access within the given timeout,
+                // sqlite3_step() will return the error SQLITE_BUSY.
+                // (without a busy_timeout, sqlite3_step() would return SQLITE_BUSY _at once_)
+                conn.busy_timeout(Duration::from_secs(10))?;
+
                 g(&conn)
             }
             None => Err(Error::SqlNoConnection),
@@ -182,14 +193,14 @@ impl Sql {
     ///
     /// Setting `None` deletes the value.  On failure an error message
     /// will already have been logged.
-    pub fn set_config(
+    pub fn set_raw_config(
         &self,
         context: &Context,
         key: impl AsRef<str>,
         value: Option<&str>,
     ) -> Result<()> {
         if !self.is_open() {
-            error!(context, "set_config(): Database not ready.");
+            error!(context, "set_raw_config(): Database not ready.");
             return Err(Error::SqlNoConnection);
         }
 
@@ -223,14 +234,14 @@ impl Sql {
         match res {
             Ok(_) => Ok(()),
             Err(err) => {
-                error!(context, "set_config(): Cannot change value. {:?}", &err);
-                Err(err.into())
+                error!(context, "set_raw_config(): Cannot change value. {:?}", &err);
+                Err(err)
             }
         }
     }
 
     /// Get configuration options from the database.
-    pub fn get_config(&self, context: &Context, key: impl AsRef<str>) -> Option<String> {
+    pub fn get_raw_config(&self, context: &Context, key: impl AsRef<str>) -> Option<String> {
         if !self.is_open() || key.as_ref().is_empty() {
             return None;
         }
@@ -241,44 +252,46 @@ impl Sql {
         )
     }
 
-    pub fn set_config_int(
+    pub fn set_raw_config_int(
         &self,
         context: &Context,
         key: impl AsRef<str>,
         value: i32,
     ) -> Result<()> {
-        self.set_config(context, key, Some(&format!("{}", value)))
+        self.set_raw_config(context, key, Some(&format!("{}", value)))
     }
 
-    pub fn get_config_int(&self, context: &Context, key: impl AsRef<str>) -> Option<i32> {
-        self.get_config(context, key).and_then(|s| s.parse().ok())
+    pub fn get_raw_config_int(&self, context: &Context, key: impl AsRef<str>) -> Option<i32> {
+        self.get_raw_config(context, key)
+            .and_then(|s| s.parse().ok())
     }
 
-    pub fn get_config_bool(&self, context: &Context, key: impl AsRef<str>) -> bool {
+    pub fn get_raw_config_bool(&self, context: &Context, key: impl AsRef<str>) -> bool {
         // Not the most obvious way to encode bool as string, but it is matter
         // of backward compatibility.
-        self.get_config_int(context, key).unwrap_or_default() > 0
+        self.get_raw_config_int(context, key).unwrap_or_default() > 0
     }
 
-    pub fn set_config_bool<T>(&self, context: &Context, key: T, value: bool) -> Result<()>
+    pub fn set_raw_config_bool<T>(&self, context: &Context, key: T, value: bool) -> Result<()>
     where
         T: AsRef<str>,
     {
         let value = if value { Some("1") } else { None };
-        self.set_config(context, key, value)
+        self.set_raw_config(context, key, value)
     }
 
-    pub fn set_config_int64(
+    pub fn set_raw_config_int64(
         &self,
         context: &Context,
         key: impl AsRef<str>,
         value: i64,
     ) -> Result<()> {
-        self.set_config(context, key, Some(&format!("{}", value)))
+        self.set_raw_config(context, key, Some(&format!("{}", value)))
     }
 
-    pub fn get_config_int64(&self, context: &Context, key: impl AsRef<str>) -> Option<i64> {
-        self.get_config(context, key).and_then(|r| r.parse().ok())
+    pub fn get_raw_config_int64(&self, context: &Context, key: impl AsRef<str>) -> Option<i64> {
+        self.get_raw_config(context, key)
+            .and_then(|r| r.parse().ok())
     }
 
     fn start_stmt(&self, stmt: impl AsRef<str>) {
@@ -330,7 +343,7 @@ fn open(
         .with_init(|c| c.execute_batch("PRAGMA secure_delete=on;"));
     let pool = r2d2::Pool::builder()
         .min_idle(Some(2))
-        .max_size(4)
+        .max_size(10)
         .connection_timeout(std::time::Duration::new(60, 0))
         .build(mgr)?;
 
@@ -466,11 +479,13 @@ fn open(
                 // cannot create the tables - maybe we cannot write?
                 return Err(Error::SqlFailedToOpen);
             } else {
-                sql.set_config_int(context, "dbversion", 0)?;
+                sql.set_raw_config_int(context, "dbversion", 0)?;
             }
         } else {
             exists_before_update = 1;
-            dbversion_before_update = sql.get_config_int(context, "dbversion").unwrap_or_default();
+            dbversion_before_update = sql
+                .get_raw_config_int(context, "dbversion")
+                .unwrap_or_default();
         }
 
         // (1) update low-level database structure.
@@ -482,6 +497,7 @@ fn open(
         let mut update_file_paths = 0;
 
         if dbversion < 1 {
+            info!(context, "[migration] v1");
             sql.execute(
                 "CREATE TABLE leftgrps ( id INTEGER PRIMARY KEY, grpid TEXT DEFAULT '');",
                 params![],
@@ -491,17 +507,19 @@ fn open(
                 params![],
             )?;
             dbversion = 1;
-            sql.set_config_int(context, "dbversion", 1)?;
+            sql.set_raw_config_int(context, "dbversion", 1)?;
         }
         if dbversion < 2 {
+            info!(context, "[migration] v2");
             sql.execute(
                 "ALTER TABLE contacts ADD COLUMN authname TEXT DEFAULT '';",
                 params![],
             )?;
             dbversion = 2;
-            sql.set_config_int(context, "dbversion", 2)?;
+            sql.set_raw_config_int(context, "dbversion", 2)?;
         }
         if dbversion < 7 {
+            info!(context, "[migration] v7");
             sql.execute(
                 "CREATE TABLE keypairs (\
                  id INTEGER PRIMARY KEY, \
@@ -513,9 +531,10 @@ fn open(
                 params![],
             )?;
             dbversion = 7;
-            sql.set_config_int(context, "dbversion", 7)?;
+            sql.set_raw_config_int(context, "dbversion", 7)?;
         }
         if dbversion < 10 {
+            info!(context, "[migration] v10");
             sql.execute(
                 "CREATE TABLE acpeerstates (\
                  id INTEGER PRIMARY KEY, \
@@ -531,9 +550,10 @@ fn open(
                 params![],
             )?;
             dbversion = 10;
-            sql.set_config_int(context, "dbversion", 10)?;
+            sql.set_raw_config_int(context, "dbversion", 10)?;
         }
         if dbversion < 12 {
+            info!(context, "[migration] v12");
             sql.execute(
                 "CREATE TABLE msgs_mdns ( msg_id INTEGER,  contact_id INTEGER);",
                 params![],
@@ -543,9 +563,10 @@ fn open(
                 params![],
             )?;
             dbversion = 12;
-            sql.set_config_int(context, "dbversion", 12)?;
+            sql.set_raw_config_int(context, "dbversion", 12)?;
         }
         if dbversion < 17 {
+            info!(context, "[migration] v17");
             sql.execute(
                 "ALTER TABLE chats ADD COLUMN archived INTEGER DEFAULT 0;",
                 params![],
@@ -557,18 +578,20 @@ fn open(
             )?;
             sql.execute("CREATE INDEX msgs_index5 ON msgs (starred);", params![])?;
             dbversion = 17;
-            sql.set_config_int(context, "dbversion", 17)?;
+            sql.set_raw_config_int(context, "dbversion", 17)?;
         }
         if dbversion < 18 {
+            info!(context, "[migration] v18");
             sql.execute(
                 "ALTER TABLE acpeerstates ADD COLUMN gossip_timestamp INTEGER DEFAULT 0;",
                 params![],
             )?;
             sql.execute("ALTER TABLE acpeerstates ADD COLUMN gossip_key;", params![])?;
             dbversion = 18;
-            sql.set_config_int(context, "dbversion", 18)?;
+            sql.set_raw_config_int(context, "dbversion", 18)?;
         }
         if dbversion < 27 {
+            info!(context, "[migration] v27");
             sql.execute("DELETE FROM msgs WHERE chat_id=1 OR chat_id=2;", params![])?;
             sql.execute(
                 "CREATE INDEX chats_contacts_index2 ON chats_contacts (contact_id);",
@@ -583,9 +606,10 @@ fn open(
                 params![],
             )?;
             dbversion = 27;
-            sql.set_config_int(context, "dbversion", 27)?;
+            sql.set_raw_config_int(context, "dbversion", 27)?;
         }
         if dbversion < 34 {
+            info!(context, "[migration] v34");
             sql.execute(
                 "ALTER TABLE msgs ADD COLUMN hidden INTEGER DEFAULT 0;",
                 params![],
@@ -612,9 +636,10 @@ fn open(
             )?;
             recalc_fingerprints = 1;
             dbversion = 34;
-            sql.set_config_int(context, "dbversion", 34)?;
+            sql.set_raw_config_int(context, "dbversion", 34)?;
         }
         if dbversion < 39 {
+            info!(context, "[migration] v39");
             sql.execute(
                 "CREATE TABLE tokens ( id INTEGER PRIMARY KEY, namespc INTEGER DEFAULT 0, foreign_id INTEGER DEFAULT 0, token TEXT DEFAULT '', timestamp INTEGER DEFAULT 0);",
                 params![]
@@ -642,32 +667,37 @@ fn open(
                 )?;
             }
             dbversion = 39;
-            sql.set_config_int(context, "dbversion", 39)?;
+            sql.set_raw_config_int(context, "dbversion", 39)?;
         }
         if dbversion < 40 {
+            info!(context, "[migration] v40");
             sql.execute(
                 "ALTER TABLE jobs ADD COLUMN thread INTEGER DEFAULT 0;",
                 params![],
             )?;
             dbversion = 40;
-            sql.set_config_int(context, "dbversion", 40)?;
+            sql.set_raw_config_int(context, "dbversion", 40)?;
         }
         if dbversion < 41 {
+            info!(context, "[migration] v41");
             update_file_paths = 1;
             dbversion = 41;
-            sql.set_config_int(context, "dbversion", 41)?;
+            sql.set_raw_config_int(context, "dbversion", 41)?;
         }
         if dbversion < 42 {
+            info!(context, "[migration] v42");
             sql.execute("UPDATE msgs SET txt='' WHERE type!=10", params![])?;
             dbversion = 42;
-            sql.set_config_int(context, "dbversion", 42)?;
+            sql.set_raw_config_int(context, "dbversion", 42)?;
         }
         if dbversion < 44 {
+            info!(context, "[migration] v44");
             sql.execute("ALTER TABLE msgs ADD COLUMN mime_headers TEXT;", params![])?;
             dbversion = 44;
-            sql.set_config_int(context, "dbversion", 44)?;
+            sql.set_raw_config_int(context, "dbversion", 44)?;
         }
         if dbversion < 46 {
+            info!(context, "[migration] v46");
             sql.execute(
                 "ALTER TABLE msgs ADD COLUMN mime_in_reply_to TEXT;",
                 params![],
@@ -677,7 +707,7 @@ fn open(
                 params![],
             )?;
             dbversion = 46;
-            sql.set_config_int(context, "dbversion", 46)?;
+            sql.set_raw_config_int(context, "dbversion", 46)?;
         }
         if dbversion < 47 {
             info!(context, "[migration] v47");
@@ -686,7 +716,7 @@ fn open(
                 params![],
             )?;
             dbversion = 47;
-            sql.set_config_int(context, "dbversion", 47)?;
+            sql.set_raw_config_int(context, "dbversion", 47)?;
         }
         if dbversion < 48 {
             info!(context, "[migration] v48");
@@ -696,7 +726,7 @@ fn open(
             )?;
 
             dbversion = 48;
-            sql.set_config_int(context, "dbversion", 48)?;
+            sql.set_raw_config_int(context, "dbversion", 48)?;
         }
         if dbversion < 49 {
             info!(context, "[migration] v49");
@@ -705,15 +735,15 @@ fn open(
                 params![],
             )?;
             dbversion = 49;
-            sql.set_config_int(context, "dbversion", 49)?;
+            sql.set_raw_config_int(context, "dbversion", 49)?;
         }
         if dbversion < 50 {
             info!(context, "[migration] v50");
             if 0 != exists_before_update {
-                sql.set_config_int(context, "show_emails", 2)?;
+                sql.set_raw_config_int(context, "show_emails", 2)?;
             }
             dbversion = 50;
-            sql.set_config_int(context, "dbversion", 50)?;
+            sql.set_raw_config_int(context, "dbversion", 50)?;
         }
         if dbversion < 53 {
             info!(context, "[migration] v53");
@@ -746,7 +776,7 @@ fn open(
                 params![],
             )?;
             dbversion = 53;
-            sql.set_config_int(context, "dbversion", 53)?;
+            sql.set_raw_config_int(context, "dbversion", 53)?;
         }
         if dbversion < 54 {
             info!(context, "[migration] v54");
@@ -756,18 +786,20 @@ fn open(
             )?;
             sql.execute("CREATE INDEX msgs_index6 ON msgs (location_id);", params![])?;
             dbversion = 54;
-            sql.set_config_int(context, "dbversion", 54)?;
+            sql.set_raw_config_int(context, "dbversion", 54)?;
         }
         if dbversion < 55 {
+            info!(context, "[migration] v55");
             sql.execute(
                 "ALTER TABLE locations ADD COLUMN independent INTEGER DEFAULT 0;",
                 params![],
             )?;
 
-            sql.set_config_int(context, "dbversion", 55)?;
+            sql.set_raw_config_int(context, "dbversion", 55)?;
         }
 
         if 0 != recalc_fingerprints {
+            info!(context, "[migration] recalc fingerprints");
             sql.query_map(
                 "SELECT addr FROM acpeerstates;",
                 params![],
@@ -777,7 +809,7 @@ fn open(
                         if let Some(ref mut peerstate) = Peerstate::from_addr(context, sql, &addr?)
                         {
                             peerstate.recalc_fingerprint();
-                            peerstate.save_to_db(sql, false).unwrap();
+                            peerstate.save_to_db(sql, false)?;
                         }
                     }
                     Ok(())
@@ -788,11 +820,9 @@ fn open(
             // versions before 2018-08 save the absolute paths in the database files at "param.f=";
             // for newer versions, we copy files always to the blob directory and store relative paths.
             // this snippet converts older databases and can be removed after some time.
-
-            info!(context, "[open] update file paths");
-
+            info!(context, "[migration] update file paths");
             let repl_from = sql
-                .get_config(context, "backup_for")
+                .get_raw_config(context, "backup_for")
                 .unwrap_or_else(|| context.get_blobdir().to_string_lossy().into());
 
             let repl_from = dc_ensure_no_slash_safe(&repl_from);
@@ -812,7 +842,7 @@ fn open(
                 NO_PARAMS,
             )?;
 
-            sql.set_config(context, "backup_for", None)?;
+            sql.set_raw_config(context, "backup_for", None)?;
         }
     }
 
@@ -1133,12 +1163,8 @@ mod test {
         maybe_add_file(&mut files, "$BLOBDIR/world.txt");
         maybe_add_file(&mut files, "world2.txt");
 
-        assert!(is_file_in_use(&mut files, None, "hello"));
-        assert!(!is_file_in_use(&mut files, Some(".txt"), "hello"));
-        assert!(is_file_in_use(
-            &mut files,
-            Some("-suffix"),
-            "world.txt-suffix"
-        ));
+        assert!(is_file_in_use(&files, None, "hello"));
+        assert!(!is_file_in_use(&files, Some(".txt"), "hello"));
+        assert!(is_file_in_use(&files, Some("-suffix"), "world.txt-suffix"));
     }
 }

src/stock.rs

@@ -109,6 +109,8 @@ pub enum StockMessage {
     MsgLocationDisabled = 65,
     #[strum(props(fallback = "Location"))]
     Location = 66,
+    #[strum(props(fallback = "Sticker"))]
+    Sticker = 67,
 }
 
 impl StockMessage {
@@ -116,7 +118,7 @@ impl StockMessage {
     ///
     /// These could be used in logging calls, so no logging here.
     fn fallback(&self) -> &'static str {
-        self.get_str("fallback").unwrap()
+        self.get_str("fallback").unwrap_or_default()
     }
 }
 
@@ -131,7 +133,7 @@ impl Context {
         if ptr.is_null() {
             Cow::Borrowed(id.fallback())
         } else {
-            let ret = to_string(ptr);
+            let ret = to_string_lossy(ptr);
             unsafe { libc::free(ptr as *mut libc::c_void) };
             Cow::Owned(ret)
         }
@@ -349,9 +351,7 @@ mod tests {
         let contact_id = {
             Contact::create(&t.ctx, "Alice", "alice@example.com")
                 .expect("Failed to create contact Alice");
-            let id =
-                Contact::create(&t.ctx, "Bob", "bob@example.com").expect("failed to create bob");
-            id
+            Contact::create(&t.ctx, "Bob", "bob@example.com").expect("failed to create bob")
         };
         assert_eq!(
             t.ctx.stock_system_msg(

src/top_evil_rs.py

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

src/wrapmime.rs

@@ -1,9 +1,14 @@
+use std::collections::HashSet;
 use std::ffi::CString;
 use std::ptr;
 
+use crate::contact::addr_normalize;
+use crate::dc_strencode::*;
 use crate::dc_tools::*;
 use crate::error::Error;
 use mmime::clist::*;
+// use mmime::display::*;
+use mmime::mailimf::mailimf_msg_id_parse;
 use mmime::mailimf::types::*;
 use mmime::mailimf::types_helper::*;
 use mmime::mailmime::content::*;
@@ -11,6 +16,7 @@ use mmime::mailmime::disposition::*;
 use mmime::mailmime::types::*;
 use mmime::mailmime::types_helper::*;
 use mmime::mailmime::*;
+use mmime::mmapstring::*;
 use mmime::other::*;
 
 #[macro_export]
@@ -36,13 +42,30 @@ pub fn get_ct_subtype(mime: *mut Mailmime) -> Option<String> {
         let ct: *mut mailmime_content = (*mime).mm_content_type;
 
         if !ct.is_null() && !(*ct).ct_subtype.is_null() {
-            Some(to_string((*ct).ct_subtype))
+            Some(to_string_lossy((*ct).ct_subtype))
         } else {
             None
         }
     }
 }
 
+pub fn parse_message_id(message_id: &str) -> Result<String, Error> {
+    let mut dummy = 0;
+    let c_message_id = CString::new(message_id).unwrap_or_default();
+    let c_ptr = c_message_id.as_ptr();
+    let mut rfc724_mid_c = std::ptr::null_mut();
+    if unsafe { mailimf_msg_id_parse(c_ptr, libc::strlen(c_ptr), &mut dummy, &mut rfc724_mid_c) }
+        == MAIL_NO_ERROR as libc::c_int
+        && !rfc724_mid_c.is_null()
+    {
+        let res = to_string_lossy(rfc724_mid_c);
+        unsafe { libc::free(rfc724_mid_c.cast()) };
+        Ok(res)
+    } else {
+        bail!("could not parse message_id: {}", message_id);
+    }
+}
+
 pub fn get_autocrypt_mime(
     mime_undetermined: *mut Mailmime,
 ) -> Result<(*mut Mailmime, *mut Mailmime), Error> {
@@ -88,6 +111,192 @@ pub fn has_decryptable_data(mime_data: *mut mailmime_data) -> bool {
     }
 }
 
+pub fn get_field_from(imffields: *mut mailimf_fields) -> Result<String, Error> {
+    let field = mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
+    if !field.is_null() && unsafe { !(*field).fld_data.fld_from.is_null() } {
+        let mb_list = unsafe { (*(*field).fld_data.fld_from).frm_mb_list };
+        if let Some(addr) = mailimf_find_first_addr(mb_list) {
+            return Ok(addr);
+        }
+    }
+    bail!("not From field found");
+}
+
+pub fn get_field_date(imffields: *mut mailimf_fields) -> Result<i64, Error> {
+    let field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
+    let mut message_time = 0;
+
+    if !field.is_null() && unsafe { !(*field).fld_data.fld_orig_date.is_null() } {
+        let orig_date = unsafe { (*field).fld_data.fld_orig_date };
+
+        if !orig_date.is_null() {
+            let dt = unsafe { (*orig_date).dt_date_time };
+            message_time = dc_timestamp_from_date(dt);
+            if message_time != 0 && message_time > time() {
+                message_time = time()
+            }
+        }
+    }
+
+    Ok(message_time)
+}
+
+fn mailimf_get_recipients_add_addr(recipients: &mut HashSet<String>, mb: *mut mailimf_mailbox) {
+    if !mb.is_null() {
+        let addr_norm = addr_normalize(as_str(unsafe { (*mb).mb_addr_spec }));
+        recipients.insert(addr_norm.into());
+    }
+}
+
+/*the result is a pointer to mime, must not be freed*/
+pub fn mailimf_find_field(
+    header: *mut mailimf_fields,
+    wanted_fld_type: libc::c_int,
+) -> *mut mailimf_field {
+    if header.is_null() {
+        return ptr::null_mut();
+    }
+
+    let header = unsafe { (*header) };
+    if header.fld_list.is_null() {
+        return ptr::null_mut();
+    }
+
+    for cur in unsafe { &(*header.fld_list) } {
+        let field = cur as *mut mailimf_field;
+        if !field.is_null() {
+            if unsafe { (*field).fld_type } == wanted_fld_type {
+                return field;
+            }
+        }
+    }
+
+    ptr::null_mut()
+}
+
+/*the result is a pointer to mime, must not be freed*/
+pub fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
+    if mime.is_null() {
+        return ptr::null_mut();
+    }
+
+    match unsafe { (*mime).mm_type as _ } {
+        MAILMIME_MULTIPLE => {
+            for cur_data in unsafe { (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() } {
+                let header = mailmime_find_mailimf_fields(cur_data as *mut _);
+                if !header.is_null() {
+                    return header;
+                }
+            }
+        }
+        MAILMIME_MESSAGE => return unsafe { (*mime).mm_data.mm_message.mm_fields },
+        _ => {}
+    }
+
+    ptr::null_mut()
+}
+
+pub unsafe fn mailimf_find_optional_field(
+    header: *mut mailimf_fields,
+    wanted_fld_name: *const libc::c_char,
+) -> *mut mailimf_optional_field {
+    if header.is_null() || (*header).fld_list.is_null() {
+        return ptr::null_mut();
+    }
+    for cur_data in (*(*header).fld_list).into_iter() {
+        let field: *mut mailimf_field = cur_data as *mut _;
+
+        if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
+            let optional_field: *mut mailimf_optional_field = (*field).fld_data.fld_optional_field;
+            if !optional_field.is_null()
+                && !(*optional_field).fld_name.is_null()
+                && !(*optional_field).fld_value.is_null()
+                && strcasecmp((*optional_field).fld_name, wanted_fld_name) == 0i32
+            {
+                return optional_field;
+            }
+        }
+    }
+
+    ptr::null_mut()
+}
+
+pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String> {
+    /* returned addresses are normalized. */
+    let mut recipients: HashSet<String> = Default::default();
+
+    for cur in unsafe { (*(*imffields).fld_list).into_iter() } {
+        let fld = cur as *mut mailimf_field;
+
+        let fld_to: *mut mailimf_to;
+        let fld_cc: *mut mailimf_cc;
+
+        let mut addr_list: *mut mailimf_address_list = ptr::null_mut();
+        if fld.is_null() {
+            continue;
+        }
+
+        let fld = unsafe { *fld };
+
+        // TODO match on enums /rtn
+        match fld.fld_type {
+            13 => {
+                fld_to = unsafe { fld.fld_data.fld_to };
+                if !fld_to.is_null() {
+                    addr_list = unsafe { (*fld_to).to_addr_list };
+                }
+            }
+            14 => {
+                fld_cc = unsafe { fld.fld_data.fld_cc };
+                if !fld_cc.is_null() {
+                    addr_list = unsafe { (*fld_cc).cc_addr_list };
+                }
+            }
+            _ => {}
+        }
+
+        if !addr_list.is_null() {
+            for cur2 in unsafe { &(*(*addr_list).ad_list) } {
+                let adr = cur2 as *mut mailimf_address;
+
+                if adr.is_null() {
+                    continue;
+                }
+                let adr = unsafe { *adr };
+
+                if adr.ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
+                    mailimf_get_recipients_add_addr(&mut recipients, unsafe {
+                        adr.ad_data.ad_mailbox
+                    });
+                } else if adr.ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
+                    let group = unsafe { adr.ad_data.ad_group };
+                    if !group.is_null() && unsafe { !(*group).grp_mb_list.is_null() } {
+                        for cur3 in unsafe { &(*(*(*group).grp_mb_list).mb_list) } {
+                            mailimf_get_recipients_add_addr(
+                                &mut recipients,
+                                cur3 as *mut mailimf_mailbox,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    recipients
+}
+
+pub fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, Error> {
+    ensure!(!mime.is_null(), "invalid inputs");
+
+    let mime_transfer_encoding =
+        get_mime_transfer_encoding(mime).unwrap_or(MAILMIME_MECHANISM_BINARY as i32);
+
+    let mime_data = unsafe { (*mime).mm_data.mm_single };
+
+    decode_dt_data(mime_data, mime_transfer_encoding)
+}
+
 pub fn get_mime_transfer_encoding(mime: *mut Mailmime) -> Option<libc::c_int> {
     unsafe {
         let mm_mime_fields = (*mime).mm_mime_fields;
@@ -108,48 +317,77 @@ pub fn get_mime_transfer_encoding(mime: *mut Mailmime) -> Option<libc::c_int> {
 pub fn decode_dt_data(
     mime_data: *mut mailmime_data,
     mime_transfer_encoding: libc::c_int,
-) -> Result<(*mut libc::c_char, libc::size_t), Error> {
+) -> Result<Vec<u8>, Error> {
     // Decode data according to mime_transfer_encoding
     // returns Ok with a (decoded_data,decoded_data_bytes) pointer
     // where the caller must make sure to free it.
     // It may return Ok(ptr::null_mut(), 0)
-
-    let mut transfer_decoding_buffer: *mut libc::c_char = ptr::null_mut();
-    let decoded_data: *mut libc::c_char;
-    let mut decoded_data_bytes: libc::size_t = 0;
     if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int
         || mime_transfer_encoding == MAILMIME_MECHANISM_8BIT as libc::c_int
         || mime_transfer_encoding == MAILMIME_MECHANISM_BINARY as libc::c_int
     {
-        unsafe {
-            decoded_data = (*mime_data).dt_data.dt_text.dt_data as *mut _;
-            decoded_data_bytes = (*mime_data).dt_data.dt_text.dt_length;
-        }
-        ensure!(
-            !decoded_data.is_null() && decoded_data_bytes > 0,
-            "could not decode mime message"
-        );
-    } else {
-        let mut current_index: libc::size_t = 0;
-        unsafe {
-            let r = mailmime_part_parse(
-                (*mime_data).dt_data.dt_text.dt_data,
-                (*mime_data).dt_data.dt_text.dt_length,
-                &mut current_index,
-                mime_transfer_encoding,
-                &mut transfer_decoding_buffer,
-                &mut decoded_data_bytes,
-            );
-            if r != MAILIMF_NO_ERROR as libc::c_int
-                || transfer_decoding_buffer.is_null()
-                || decoded_data_bytes <= 0
-            {
-                bail!("mailmime_part_parse returned error or invalid data");
-            }
-            decoded_data = transfer_decoding_buffer;
+        let decoded_data = unsafe { (*mime_data).dt_data.dt_text.dt_data };
+        let decoded_data_bytes = unsafe { (*mime_data).dt_data.dt_text.dt_length };
+
+        if decoded_data.is_null() || decoded_data_bytes == 0 {
+            bail!("No data to decode found");
+        } else {
+            let result = unsafe {
+                std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes)
+            };
+            return Ok(result.to_vec());
         }
     }
-    Ok((decoded_data, decoded_data_bytes))
+    // unsafe { display_mime_data(mime_data) };
+
+    let mut current_index = 0;
+    let mut transfer_decoding_buffer = ptr::null_mut();
+    let mut decoded_data_bytes = 0;
+
+    let r = unsafe {
+        mailmime_part_parse(
+            (*mime_data).dt_data.dt_text.dt_data,
+            (*mime_data).dt_data.dt_text.dt_length,
+            &mut current_index,
+            mime_transfer_encoding,
+            &mut transfer_decoding_buffer,
+            &mut decoded_data_bytes,
+        )
+    };
+
+    if r == MAILIMF_NO_ERROR as libc::c_int
+        && !transfer_decoding_buffer.is_null()
+        && decoded_data_bytes > 0
+    {
+        let result = unsafe {
+            std::slice::from_raw_parts(transfer_decoding_buffer as *const u8, decoded_data_bytes)
+        }
+        .to_vec();
+        // we return a fresh vec and transfer_decoding_buffer is not used or passed anywhere
+        // so it's safe to free it right away, as mailman_part_parse has
+        // allocated it fresh.
+        unsafe { mmap_string_unref(transfer_decoding_buffer) };
+
+        return Ok(result);
+    }
+
+    Err(format_err!("Failed to to decode"))
+}
+
+pub fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> Option<String> {
+    if mb_list.is_null() {
+        return None;
+    }
+
+    for cur in unsafe { (*(*mb_list).mb_list).into_iter() } {
+        let mb = cur as *mut mailimf_mailbox;
+        if !mb.is_null() && !unsafe { (*mb).mb_addr_spec.is_null() } {
+            let addr = unsafe { as_str((*mb).mb_addr_spec) };
+            return Some(addr_normalize(addr).to_string());
+        }
+    }
+
+    None
 }
 
 /**************************************
@@ -210,8 +448,8 @@ pub fn append_ct_param(
     value: &str,
 ) -> Result<(), Error> {
     unsafe {
-        let name_c = CString::new(name).unwrap();
-        let value_c = CString::new(value).unwrap();
+        let name_c = CString::new(name).unwrap_or_default();
+        let value_c = CString::new(value).unwrap_or_default();
 
         clist_append!(
             (*content).ct_parameters,
@@ -225,7 +463,7 @@ pub fn append_ct_param(
 }
 
 pub fn new_content_type(content_type: &str) -> Result<*mut mailmime_content, Error> {
-    let ct = CString::new(content_type).unwrap();
+    let ct = CString::new(content_type).unwrap_or_default();
     let content: *mut mailmime_content;
     // mailmime_content_new_with_str only parses but does not retain/own ct
     unsafe {
@@ -261,6 +499,24 @@ pub fn content_type_needs_encoding(content: *const mailmime_content) -> bool {
     }
 }
 
+pub fn new_mailbox_list(displayname: &str, addr: &str) -> *mut mailimf_mailbox_list {
+    let mbox: *mut mailimf_mailbox_list = unsafe { mailimf_mailbox_list_new_empty() };
+    unsafe {
+        mailimf_mailbox_list_add(
+            mbox,
+            mailimf_mailbox_new(
+                if !displayname.is_empty() {
+                    dc_encode_header_words(&displayname).strdup()
+                } else {
+                    ptr::null_mut()
+                },
+                addr.strdup(),
+            ),
+        );
+    }
+    mbox
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -280,4 +536,16 @@ mod tests {
             new_content_type("application/pgp-encrypted").unwrap()
         ));
     }
+
+    #[test]
+    fn test_parse_message_id() {
+        assert_eq!(
+            parse_message_id("Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org").unwrap(),
+            "Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org"
+        );
+        assert_eq!(
+            parse_message_id("<Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org>").unwrap(),
+            "Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org"
+        );
+    }
 }