bring back memory leak

(and possibly also related to #633)

deltachat-ffi/deltachat.h

@@ -3719,14 +3719,6 @@ 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()
@@ -3904,25 +3896,6 @@ 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
 
 /**
  * The library-user should write a warning string to the log.

deltachat-ffi/src/lib.rs

@@ -125,8 +125,6 @@ impl ContextWrapper {
                     | Event::SmtpConnected(msg)
                     | Event::ImapConnected(msg)
                     | Event::SmtpMessageSent(msg)
-                    | Event::ImapMessageDeleted(msg)
-                    | Event::ImapMessageMoved(msg)
                     | Event::Warning(msg)
                     | Event::Error(msg)
                     | Event::ErrorNetwork(msg)
@@ -1247,11 +1245,8 @@ 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_log_default(ctx, "Failed to forward message")
-        })
-        .unwrap_or_default()
+        .with_inner(|ctx| chat::forward_msgs(ctx, ids, chat_id))
+        .unwrap_or(())
 }
 
 #[no_mangle]

examples/repl/cmdline.rs

@@ -864,7 +864,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/display.rs

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

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_pw=..." a test account login that will
+  via "addr=... mail_pwd=..." 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

@@ -258,10 +258,6 @@ class Account(object):
         """ return Message instance. """
         return Message.from_db(self, msg_id)
 
-    def get_chat_by_id(self, chat_id):
-        """ return Chat instance. """
-        return Chat(self, chat_id)
-
     def mark_seen_messages(self, messages):
         """ mark the given set of messages as seen.
 
@@ -578,11 +574,11 @@ class EventLogger:
             else:
                 assert not rex.match(ev[0]), "event found {}".format(ev)
 
-    def get_matching(self, event_name_regex, check_error=True, timeout=None):
+    def get_matching(self, event_name_regex, check_error=True):
         self._log("-- waiting for event with regex: {} --".format(event_name_regex))
         rex = re.compile("(?:{}).*".format(event_name_regex))
         while 1:
-            ev = self.get(timeout=timeout, check_error=check_error)
+            ev = self.get()
             if rex.match(ev[0]):
                 return ev
 

python/src/deltachat/const.py

@@ -8,6 +8,9 @@ from os.path import join as joinpath
 # this works well when you in a git-checkout
 # run "python deltachat/const.py" to regenerate events
 # begin const generated
+DC_PROVIDER_STATUS_OK = 1
+DC_PROVIDER_STATUS_PREPARATION = 2
+DC_PROVIDER_STATUS_BROKEN = 3
 DC_GCL_ARCHIVED_ONLY = 0x01
 DC_GCL_NO_SPECIALS = 0x02
 DC_GCL_ADD_ALLDONE_HINT = 0x04
@@ -52,7 +55,6 @@ 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
@@ -61,8 +63,6 @@ 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_WARNING = 300
 DC_EVENT_ERROR = 400
 DC_EVENT_ERROR_NETWORK = 401
@@ -83,9 +83,6 @@ 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,11 +157,6 @@ 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,7 +1,6 @@
 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
@@ -20,7 +19,6 @@ 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()
@@ -39,11 +37,6 @@ 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):
@@ -100,7 +93,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 message")
+        msg = chat.send_text("one messae")
         assert not ac1.delete_contact(contact1)
         assert not msg.filemime
 
@@ -358,32 +351,18 @@ class TestOnlineAccount:
         ac1._evlogger.consume_events()
         ac1.import_self_keys(dir.strpath)
 
-    def test_one_account_send_bcc_setting(self, acfactory, lp):
+    def test_one_account_send(self, acfactory):
         ac1 = acfactory.get_online_configuring_account()
-        c2 = ac1.create_contact(email="notexists@testrun.org")
+        c2 = ac1.create_contact(email=ac1.get_config("addr"))
         chat = ac1.create_chat_by_contact(c2)
         assert chat.id > const.DC_CHAT_ID_LAST_SPECIAL
         wait_successful_IMAP_SMTP_connection(ac1)
         wait_configuration_progress(ac1, 1000)
 
-        lp.sec("send out message with bcc to ourselves")
         msg_out = chat.send_text("message2")
-        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]
-
-        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]
+        # 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
 
     def test_mvbox_sentbox_threads(self, acfactory):
         ac1 = acfactory.get_online_configuring_account(mvbox=True, sentbox=True)
@@ -395,17 +374,6 @@ 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)
@@ -476,14 +444,6 @@ 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()
 
@@ -616,9 +576,6 @@ 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):
@@ -734,45 +691,3 @@ class TestOnlineConfigureFails:
         ev1 = ac1._evlogger.get_matching("DC_EVENT_ERROR_NETWORK")
         assert "could not connect" in ev1[2].lower()
         wait_configuration_progress(ac1, 0, 0)
-
-
-class TestThreeAccounts:
-    def test_verified_export_import(self, acfactory, lp, tmpdir):
-        ac1, ac2 = acfactory.get_two_online_accounts()
-        lp.sec("ac1: create verified-group QR, ac2 scans and joins")
-        chat1 = ac1.create_group_chat("hello", verified=True)
-        assert chat1.is_verified()
-        qr = chat1.get_join_qr()
-        lp.sec("ac2: start QR-code based join-group protocol")
-        chat2 = ac2.qr_join_chat(qr)
-        assert chat2.id >= 10
-        wait_securejoin_inviter_progress(ac1, 1000)
-
-        lp.sec("ac2: read member added message")
-        msg = ac2.wait_next_incoming_message()
-        assert msg.is_encrypted()
-        assert "added" in msg.text.lower()
-        assert msg.chat.is_verified()
-
-        lp.sec("export ac1")
-        backupdir = tmpdir.mkdir("backup")
-        path = ac1.export_all(backupdir.strpath)
-        assert os.path.exists(path)
-
-        lp.sec("ac3: import ac1-state")
-        ac3 = acfactory.get_unconfigured_account()
-        ac3.import_all(path)
-        ch3 = ac3.get_chat_by_id(chat1.id)
-        assert ch3.is_verified()
-        ac3.start_threads()
-
-        lp.sec("ac3: send message")
-        msg_out = ch3.send_text("hello")
-        assert msg_out.is_encrypted()
-
-        lp.sec("ac2: read message and check it's verified chat")
-        msg = ac2.wait_next_incoming_message()
-        assert msg.text == "hello"
-        assert msg.is_encrypted()
-        assert msg.chat.is_verified()
-

src/aheader.rs

@@ -88,15 +88,18 @@ impl Aheader {
                             .unwrap()
                     };
 
-                    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;
+                    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;
+                                }
                             }
                         }
+                        _ => {}
                     }
                 }
             }
@@ -128,9 +131,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;
                 }
@@ -175,7 +178,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().any(|k| !k.starts_with('_')) {
+        if attributes.keys().find(|k| !k.starts_with("_")).is_some() {
             return Err(());
         }
 

src/chat.rs

@@ -152,10 +152,12 @@ 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);
+            return context
+                .stock_string_repl_int(StockMessage::Member, cnt as i32)
+                .into();
         }
 
-        "Err".to_string()
+        return "Err".into();
     }
 
     pub fn get_parent_mime_headers(&self, context: &Context) -> Option<(String, String, String)> {
@@ -297,7 +299,11 @@ 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.get_config_bool(Config::E2eeEnabled);
+            e2ee_enabled = context
+                .sql
+                .get_config_int(context, "e2ee_enabled")
+                .unwrap_or_else(|| 1)
+                == 1;
             if e2ee_enabled && msg.param.get_int(Param::ForcePlaintext).unwrap_or_default() == 0 {
                 let mut can_encrypt = 1;
                 let mut all_mutual = 1;
@@ -640,7 +646,6 @@ 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,
@@ -778,7 +783,10 @@ pub fn send_msg(context: &Context, chat_id: u32, msg: &mut Message) -> Result<u3
         message::update_msg_state(context, msg.id, MessageState::OutPending);
     }
 
-    job_send_msg(context, msg.id)?;
+    ensure!(
+        job_send_msg(context, msg.id) != 0,
+        "Failed to initiate send job"
+    );
 
     context.call_cb(Event::MsgsChanged {
         chat_id: msg.chat_id,
@@ -797,8 +805,11 @@ 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) {
-                    send_msg(context, 0, &mut copy)?;
+                } 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();
+                    }
                 }
             }
             msg.param.remove(Param::PrepForwards);
@@ -1388,14 +1399,14 @@ pub(crate) fn add_contact_to_chat_ex(
         }
     } else {
         // else continue and send status mail
-        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 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 !add_to_chat_contacts_table(context, chat_id, contact_id) {
             return Ok(false);
@@ -1412,14 +1423,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)?;
+        msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
         context.call_cb(Event::MsgsChanged {
             chat_id,
             msg_id: msg.id,
         });
     }
     context.call_cb(Event::MsgsChanged { chat_id, msg_id: 0 });
-    Ok(true)
+    return Ok(true);
 }
 
 fn real_group_exists(context: &Context, chat_id: u32) -> bool {
@@ -1523,7 +1534,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)?;
+                        msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
                         context.call_cb(Event::MsgsChanged {
                             chat_id,
                             msg_id: msg.id,
@@ -1587,7 +1598,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!(
@@ -1620,7 +1631,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)?;
+                    msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
                     context.call_cb(Event::MsgsChanged {
                         chat_id,
                         msg_id: msg.id,
@@ -1689,7 +1700,7 @@ pub fn set_chat_profile_image(
                     "",
                     DC_CONTACT_ID_SELF,
                 ));
-                msg.id = send_msg(context, chat_id, &mut msg)?;
+                msg.id = send_msg(context, chat_id, &mut msg).unwrap_or_default();
                 emit_event!(
                     context,
                     Event::MsgsChanged {
@@ -1705,12 +1716,10 @@ pub fn set_chat_profile_image(
     bail!("Failed to set profile image");
 }
 
-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"
-    );
+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;
+    }
 
     let mut created_db_entries = Vec::new();
     let mut curr_timestamp: i64;
@@ -1719,7 +1728,7 @@ pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) -> Result<
     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
-            .iter()
+            .into_iter()
             .enumerate()
             .fold(String::with_capacity(2 * msg_ids.len()), |acc, (i, n)| {
                 (if i == 0 { acc } else { acc + "," }) + &n.to_string()
@@ -1756,7 +1765,7 @@ pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) -> Result<
             let new_msg_id: u32;
             if msg.state == MessageState::OutPreparing {
                 let fresh9 = curr_timestamp;
-                curr_timestamp += 1;
+                curr_timestamp = curr_timestamp + 1;
                 new_msg_id = chat
                     .prepare_msg_raw(context, &mut msg, fresh9)
                     .unwrap_or_default();
@@ -1776,11 +1785,11 @@ pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) -> Result<
             } else {
                 msg.state = MessageState::OutPending;
                 let fresh10 = curr_timestamp;
-                curr_timestamp += 1;
+                curr_timestamp = 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);
@@ -1793,8 +1802,6 @@ pub fn forward_msgs(context: &Context, msg_ids: &[u32], chat_id: u32) -> Result<
             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.insert(0, (DC_CHAT_ID_DEADDROP, last_deaddrop_fresh_msg_id));
+                    ids.push((1, last_deaddrop_fresh_msg_id));
                 }
                 add_archived_link_item = 1;
             }
@@ -258,11 +258,13 @@ 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 {
-            return ret;
+            if let Ok(chat) = Chat::load_from_db(context, self.ids[index].0) {
+                chat_loaded = chat;
+                &chat_loaded
+            } else {
+                return ret;
+            }
         };
 
         let lastmsg_id = self.ids[index].1;

src/config.rs

@@ -19,12 +19,10 @@ pub enum Config {
     MailUser,
     MailPw,
     MailPort,
-    ImapCertificateChecks,
     SendServer,
     SendUser,
     SendPw,
     SendPort,
-    SmtpCertificateChecks,
     ServerFlags,
     #[strum(props(default = "INBOX"))]
     ImapFolder,
@@ -32,8 +30,6 @@ pub enum Config {
     Selfstatus,
     Selfavatar,
     #[strum(props(default = "1"))]
-    BccSelf,
-    #[strum(props(default = "1"))]
     E2eeEnabled,
     #[strum(props(default = "1"))]
     MdnsEnabled,
@@ -54,12 +50,10 @@ pub enum Config {
     ConfiguredMailPw,
     ConfiguredMailPort,
     ConfiguredMailSecurity,
-    ConfiguredImapCertificateChecks,
     ConfiguredSendServer,
     ConfiguredSendUser,
     ConfiguredSendPw,
     ConfiguredSendPort,
-    ConfiguredSmtpCertificateChecks,
     ConfiguredServerFlags,
     ConfiguredSendSecurity,
     ConfiguredE2EEEnabled,
@@ -98,14 +92,6 @@ impl Context {
         }
     }
 
-    pub fn get_config_int(&self, key: Config) -> i32 {
-        self.get_config(key).and_then(|s| s.parse().ok()).unwrap()
-    }
-
-    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> {

src/configure/auto_outlook.rs

@@ -21,6 +21,7 @@ struct outlk_autodiscover_t<'a> {
     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 unsafe fn outlk_autodiscover(
@@ -37,11 +38,12 @@ pub unsafe fn outlk_autodiscover(
         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 {
+        if !(i < 10) {
             ok_to_continue = true;
             break;
         }

src/configure/mod.rs

@@ -352,7 +352,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                                 ok_to_continue8 = true;
                                 break;
                             }
-                            if param_autoconfig.is_some() {
+                            if !param_autoconfig.is_none() {
                                 ok_to_continue8 = false;
                                 break;
                             }
@@ -423,7 +423,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                             .unwrap()
                             .connect(context, &param)
                         {
-                            if param_autoconfig.is_some() {
+                            if !param_autoconfig.is_none() {
                                 success = false;
                             } else if s.shall_stop_ongoing {
                                 success = false;

src/constants.rs

@@ -25,6 +25,7 @@ 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;
@@ -194,11 +195,6 @@ 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().
@@ -303,8 +299,7 @@ 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_STICKER: usize = 67;
-const DC_STR_COUNT: usize = 67;
+const DC_STR_COUNT: usize = 66;
 
 pub const DC_JOB_DELETE_MSG_ON_IMAP: i32 = 110;
 

src/contact.rs

@@ -390,18 +390,20 @@ 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 {
-            error!(context, "Cannot add contact.");
+            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.");
+            }
         }
 
         Ok((row_id, sth_modified))
@@ -825,7 +827,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;
                 }
             }
@@ -961,9 +963,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 == b'\'' && lastchar == b'\''
-            || firstchar == b'\"' && lastchar == b'\"'
-            || firstchar == b'<' && lastchar == b'>'
+        if firstchar == '\'' as u8 && lastchar == '\'' as u8
+            || firstchar == '\"' as u8 && lastchar == '\"' as u8
+            || firstchar == '<' as u8 && lastchar == '>' as u8
         {
             full_name = &full_name[1..len - 1];
         }

src/context.rs

@@ -1,17 +1,13 @@
 use std::collections::HashMap;
 use std::ffi::OsString;
-use std::fs;
-use std::io::Write;
 use std::path::{Path, PathBuf};
 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};
 use crate::error::*;
 use crate::events::Event;
 use crate::imap::*;
@@ -24,7 +20,6 @@ use crate::message::{self, Message};
 use crate::param::Params;
 use crate::smtp::*;
 use crate::sql::Sql;
-use rand::{thread_rng, Rng};
 
 /// Callback function type for [Context]
 ///
@@ -163,57 +158,6 @@ impl Context {
         self.blobdir.as_path()
     }
 
-    pub fn copy_to_blobdir(&self, orig_filename: impl AsRef<str>) -> Result<String> {
-        // return a $BLOBDIR/<filename> with the content of orig_filename
-        // copied into it. The <filename> will be safely derived from
-        // orig_filename, and will not clash with existing filenames.
-        let dest = self.new_blob_file(&orig_filename, b"")?;
-        if dc_copy_file(
-            &self,
-            PathBuf::from(orig_filename.as_ref()),
-            PathBuf::from(&dest),
-        ) {
-            Ok(dest)
-        } else {
-            bail!("could not copy {} to {}", orig_filename.as_ref(), dest);
-        }
-    }
-
-    pub fn new_blob_file(&self, orig_filename: impl AsRef<str>, data: &[u8]) -> Result<String> {
-        // return a $BLOBDIR/<FILENAME> string which corresponds to the
-        // respective file in the blobdir, and which contains the data.
-        // FILENAME is computed by looking and possibly mangling the
-        // basename of orig_filename. The resulting filenames are meant
-        // to be human-readable.
-        let (stem, ext) = dc_derive_safe_stem_ext(orig_filename.as_ref());
-
-        // ext starts with "." or is empty string, so we can always resconstruct
-
-        for i in 0..3 {
-            let candidate_basename = match i {
-                // first a try to just use the (possibly mangled) original basename
-                0 => format!("{}{}", stem, ext),
-
-                // otherwise extend stem with random numbers
-                _ => {
-                    let mut rng = thread_rng();
-                    let random_id: u32 = rng.gen();
-                    format!("{}-{}{}", stem, random_id, ext)
-                }
-            };
-            let path = self.get_blobdir().join(&candidate_basename);
-            if let Ok(mut file) = fs::OpenOptions::new()
-                .create_new(true)
-                .write(true)
-                .open(&path)
-            {
-                file.write_all(data)?;
-                return Ok(format!("$BLOBDIR/{}", candidate_basename));
-            }
-        }
-        bail!("out of luck to create new blob file");
-    }
-
     pub fn call_cb(&self, event: Event) -> uintptr_t {
         (*self.cb)(self, event)
     }
@@ -235,10 +179,14 @@ impl Context {
             .sql
             .get_config_int(self, "dbversion")
             .unwrap_or_default();
-
-        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 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 prv_key_cnt: Option<isize> =
             self.sql
@@ -256,15 +204,26 @@ impl Context {
             "<Not yet calculated>".into()
         };
 
-        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 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 folders_configured = self
             .sql
             .get_config_int(self, "folders_configured")
             .unwrap_or_default();
-
         let configured_sentbox_folder = self
             .sql
             .get_config(self, "configured_sentbox_folder")
@@ -295,7 +254,6 @@ 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(),
@@ -480,7 +438,6 @@ pub fn get_version_str() -> &'static str {
 mod tests {
     use super::*;
 
-    use crate::dc_tools::*;
     use crate::test_utils::*;
 
     #[test]
@@ -518,51 +475,6 @@ mod tests {
         assert!(res.is_err());
     }
 
-    #[test]
-    fn test_new_blob_file() {
-        let t = dummy_context();
-        let context = t.ctx;
-        let x = &context.new_blob_file("hello", b"data").unwrap();
-        assert!(dc_file_exist(&context, x));
-        assert!(x.starts_with("$BLOBDIR"));
-        assert!(dc_read_file(&context, x).unwrap() == b"data");
-
-        let y = &context.new_blob_file("hello", b"data").unwrap();
-        assert!(dc_file_exist(&context, y));
-        assert!(y.starts_with("$BLOBDIR/hello-"));
-
-        let x = &context.new_blob_file("xyz/hello.png", b"data").unwrap();
-        assert!(dc_file_exist(&context, x));
-        assert_eq!(x, "$BLOBDIR/hello.png");
-
-        let y = &context.new_blob_file("hello\\world.png", b"data").unwrap();
-        assert!(dc_file_exist(&context, y));
-        assert_eq!(y, "$BLOBDIR/world.png");
-    }
-
-    #[test]
-    fn test_new_blob_file_long_names() {
-        let t = dummy_context();
-        let context = t.ctx;
-        let s = "12312312039182039182039812039810293810293810293810293801293801293123123";
-        let x = &context.new_blob_file(s, b"data").unwrap();
-        println!("blobfilename '{}'", x);
-        println!("xxxxfilename '{}'", s);
-        assert!(x.len() < s.len());
-        assert!(dc_file_exist(&context, x));
-        assert!(x.starts_with("$BLOBDIR"));
-    }
-
-    #[test]
-    fn test_new_blob_file_unicode() {
-        let t = dummy_context();
-        let context = t.ctx;
-        let s = "helloäworld.qwe";
-        let x = &context.new_blob_file(s, b"data").unwrap();
-        assert_eq!(x, "$BLOBDIR/hello-world.qwe");
-        assert_eq!(dc_read_file(&context, x).unwrap(), b"data");
-    }
-
     #[test]
     fn test_sqlite_parent_not_exists() {
         let tmp = tempfile::tempdir().unwrap();

src/dc_mimeparser.rs

@@ -11,6 +11,7 @@ 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;
@@ -24,7 +25,6 @@ use crate::error::Error;
 use crate::location;
 use crate::param::*;
 use crate::stock::StockMessage;
-use crate::wrapmime;
 
 #[derive(Debug)]
 pub struct MimeParser<'a> {
@@ -127,7 +127,7 @@ impl<'a> MimeParser<'a> {
                 if (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
                     let subj = (*(*field).fld_data.fld_subject).sbj_value;
 
-                    self.subject = as_opt_str(subj).map(dc_decode_header_words);
+                    self.subject = as_opt_str(subj).map(dc_decode_header_words_safe);
                 }
             }
 
@@ -164,17 +164,21 @@ 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 && self.parts.len() >= 2 {
-                    let imgpart = &mut self.parts[1];
-                    if imgpart.typ == Viewtype::Image {
-                        imgpart.is_meta = true;
+                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;
+                        }
                     }
                 }
             }
@@ -185,7 +189,6 @@ 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
@@ -253,14 +256,6 @@ 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
@@ -292,12 +287,12 @@ impl<'a> MimeParser<'a> {
                         ) == MAILIMF_NO_ERROR as libc::c_int
                             && !mb_list.is_null()
                         {
-                            if let Some(dn_to_addr) = wrapmime::mailimf_find_first_addr(mb_list) {
+                            if let Some(dn_to_addr) = 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()
                                     {
-                                        let from_addr = wrapmime::mailimf_find_first_addr(
+                                        let from_addr = mailimf_find_first_addr(
                                             (*(*from_field).fld_data.fld_from).frm_mb_list,
                                         );
                                         if let Some(from_addr) = from_addr {
@@ -595,7 +590,7 @@ impl<'a> MimeParser<'a> {
             return false;
         }
 
-        let mut decoded_data = match wrapmime::mailmime_transfer_decode(mime) {
+        let mut decoded_data = match mailmime_transfer_decode(mime) {
             Ok(decoded_data) => decoded_data,
             Err(_) => {
                 // Note that it's now always an error - might be no data
@@ -709,7 +704,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(&s)
+                                        desired_filename = dc_decode_header_words_safe(&s)
                                     }
                                 }
                             }
@@ -781,34 +776,28 @@ impl<'a> MimeParser<'a> {
         decoded_data: &[u8],
         desired_filename: &str,
     ) {
-        /* write decoded data to new blob file */
-        let bpath = match self.context.new_blob_file(desired_filename, decoded_data) {
-            Ok(path) => path,
-            Err(err) => {
-                error!(
-                    self.context,
-                    "Could not add blob for mime part {}, error {}", desired_filename, err
-                );
-                return;
-            }
-        };
+        /* create a free file name to use */
+        let path_filename = dc_get_fine_path_filename(self.context, "$BLOBDIR", desired_filename);
 
-        let mut part = Part::default();
-        part.typ = msg_type;
-        part.mimetype = mime_type;
-        part.bytes = decoded_data.len() as libc::c_int;
-        part.param.set(Param::File, bpath);
-        if let Some(raw_mime) = raw_mime {
-            part.param.set(Param::MimeType, raw_mime);
-        }
-
-        if mime_type == DC_MIMETYPE_IMAGE {
-            if let Ok((width, height)) = dc_get_filemeta(decoded_data) {
-                part.param.set_int(Param::Width, width as i32);
-                part.param.set_int(Param::Height, height as i32);
+        /* copy data to file */
+        if dc_write_file(self.context, &path_filename, decoded_data) {
+            let mut part = Part::default();
+            part.typ = msg_type;
+            part.mimetype = mime_type;
+            part.bytes = decoded_data.len() as libc::c_int;
+            part.param.set(Param::File, path_filename.to_string_lossy());
+            if let Some(raw_mime) = raw_mime {
+                part.param.set(Param::MimeType, raw_mime);
             }
+
+            if mime_type == DC_MIMETYPE_IMAGE {
+                if let Ok((width, height)) = dc_get_filemeta(decoded_data) {
+                    part.param.set_int(Param::Width, width as i32);
+                    part.param.set_int(Param::Height, height as i32);
+                }
+            }
+            self.do_add_single_part(part);
         }
-        self.do_add_single_part(part);
     }
 
     fn do_add_single_part(&mut self, mut part: Part) {
@@ -843,7 +832,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 = wrapmime::mailimf_find_field(self.header_root, MAILIMF_FIELD_FROM as libc::c_int);
+        let fld = mailimf_find_field(self.header_root, MAILIMF_FIELD_FROM as libc::c_int);
         if !(fld.is_null()
             || {
                 fld_from = (*fld).fld_data.fld_from;
@@ -861,9 +850,11 @@ impl<'a> MimeParser<'a> {
 
             if !mb.is_null() {
                 let from_addr_norm = addr_normalize(as_str((*mb).mb_addr_spec));
-                let recipients = wrapmime::mailimf_get_recipients(self.header_root);
-                if recipients.len() == 1 && recipients.contains(from_addr_norm) {
-                    sender_equals_recipient = true;
+                let recipients = mailimf_get_recipients(self.header_root);
+                if recipients.len() == 1 {
+                    if recipients.contains(from_addr_norm) {
+                        sender_equals_recipient = true;
+                    }
                 }
             }
         }
@@ -920,6 +911,22 @@ 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;
@@ -990,12 +997,14 @@ 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);
+                        }
                     }
                 }
 
@@ -1139,6 +1148,214 @@ 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::*;
@@ -1154,13 +1371,14 @@ 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 = wrapmime::mailmime_find_mailimf_fields(mime);
+            let fields: *mut mailimf_fields = mailmime_find_mailimf_fields(mime);
             assert!(!fields.is_null());
 
-            let mut of_a: *mut mailimf_optional_field = wrapmime::mailimf_find_optional_field(
+            let mut of_a: *mut mailimf_optional_field = mailimf_find_optional_field(
                 fields,
                 b"fielda\x00" as *const u8 as *const libc::c_char,
             );
@@ -1180,7 +1398,7 @@ mod tests {
                 "ValueA",
             );
 
-            of_a = wrapmime::mailimf_find_optional_field(
+            of_a = mailimf_find_optional_field(
                 fields,
                 b"FIELDA\x00" as *const u8 as *const libc::c_char,
             );
@@ -1200,7 +1418,7 @@ mod tests {
                 "ValueA",
             );
 
-            let of_b: *mut mailimf_optional_field = wrapmime::mailimf_find_optional_field(
+            let of_b: *mut mailimf_optional_field = mailimf_find_optional_field(
                 fields,
                 b"FieldB\x00" as *const u8 as *const libc::c_char,
             );
@@ -1223,9 +1441,7 @@ 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);
     }
@@ -1233,13 +1449,9 @@ 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 {
-                assert!(mimeparser.parse(data.as_bytes()).is_err());
-            }
+            unsafe { mimeparser.parse(data.as_bytes()).unwrap() };
         }
     }
 
@@ -1268,7 +1480,7 @@ mod tests {
     fn test_mimeparser_with_context() {
         unsafe {
             let context = dummy_context();
-            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 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 mut mimeparser = MimeParser::new(&context.ctx);
             mimeparser.parse(&raw[..]).unwrap();
 

src/dc_receive_imf.rs

@@ -2,9 +2,10 @@ use std::ffi::CString;
 use std::ptr;
 
 use itertools::join;
-use libc::{free, strcmp};
+use libc::{free, strcmp, strlen};
 use mmime::clist::*;
 use mmime::mailimf::types::*;
+use mmime::mailimf::*;
 use mmime::mailmime::content::*;
 use mmime::mailmime::types::*;
 use mmime::mailmime::*;
@@ -12,7 +13,6 @@ 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,7 +29,6 @@ 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 {
@@ -82,7 +81,7 @@ pub unsafe fn dc_receive_imf(
     let mut chat_id = 0;
     let mut hidden = 0;
 
-    let mut needs_delete_job = false;
+    let mut add_delete_job: libc::c_int = 0;
     let mut insert_msg_id = 0;
 
     let mut sent_timestamp = 0;
@@ -148,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.is_empty() {
+            } else if from_list.len() >= 1 {
                 // 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 [**]
@@ -219,7 +218,7 @@ pub unsafe fn dc_receive_imf(
             &mut chat_id,
             &mut to_id,
             flags,
-            &mut needs_delete_job,
+            &mut add_delete_job,
             to_self,
             &mut insert_msg_id,
             &mut created_db_entries,
@@ -250,7 +249,7 @@ pub unsafe fn dc_receive_imf(
             from_id,
             sent_timestamp,
             &mut rr_event_to_send,
-            &server_folder,
+            server_folder,
             server_uid,
         );
     }
@@ -266,8 +265,7 @@ pub unsafe fn dc_receive_imf(
         );
     }
 
-    // if we delete we don't need to try moving messages
-    if needs_delete_job && !created_db_entries.is_empty() {
+    if 0 != add_delete_job && !created_db_entries.is_empty() {
         job_add(
             context,
             Action::DeleteMsgOnImap,
@@ -275,8 +273,6 @@ pub unsafe fn dc_receive_imf(
             Params::new(),
             0,
         );
-    } else {
-        context.do_heuristics_moves(server_folder.as_ref(), insert_msg_id);
     }
 
     info!(
@@ -309,7 +305,7 @@ unsafe fn add_parts(
     chat_id: &mut u32,
     to_id: &mut u32,
     flags: u32,
-    needs_delete_job: &mut bool,
+    add_delete_job: &mut libc::c_int,
     to_self: i32,
     insert_msg_id: &mut u32,
     created_db_entries: &mut Vec<(usize, usize)>,
@@ -374,7 +370,10 @@ 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.get_config_int(Config::ShowEmails);
+        let show_emails = context
+            .sql
+            .get_config_int(context, "show_emails")
+            .unwrap_or_default();
         if show_emails == 0 {
             *chat_id = 3;
             allow_creation = 0
@@ -404,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;
-                *needs_delete_job = 0 != handshake & DC_HANDSHAKE_ADD_DELETE_JOB;
+                *add_delete_job = handshake & DC_HANDSHAKE_ADD_DELETE_JOB;
                 state = MessageState::InSeen;
             }
         }
@@ -495,12 +494,10 @@ 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
-            && !incoming_origin.is_verified()
-            && msgrmsg == 0
-        {
-            state = MessageState::InNoticed;
+        if Blocked::Not != chat_id_blocked && state == MessageState::InFresh {
+            if !incoming_origin.is_verified() && msgrmsg == 0 {
+                state = MessageState::InNoticed;
+            }
         }
     } else {
         // Outgoing
@@ -629,7 +626,7 @@ unsafe fn add_parts(
                     }
 
                     if let Some(ref msg) = part.msg {
-                        if mime_parser.location_kml.is_some()
+                        if !mime_parser.location_kml.is_none()
                             && icnt == 1
                             && (msg == "-location-" || msg.is_empty())
                         {
@@ -723,6 +720,7 @@ unsafe fn add_parts(
         }
     }
 
+    context.do_heuristics_moves(server_folder.as_ref(), *insert_msg_id);
     cleanup(mime_in_reply_to, mime_references);
 
     Ok(())
@@ -738,7 +736,10 @@ unsafe fn handle_reports(
     server_folder: impl AsRef<str>,
     server_uid: u32,
 ) {
-    let mdns_enabled = context.get_config_bool(Config::MdnsEnabled);
+    let mdns_enabled = context
+        .sql
+        .get_config_int(context, "mdns_enabled")
+        .unwrap_or_else(|| DC_MDNS_DEFAULT_ENABLED);
 
     for report_root in &mime_parser.reports {
         let report_root = *report_root;
@@ -757,7 +758,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 mdns_enabled {
+            if 0 != mdns_enabled {
                 let report_data = (if !if !(*(*report_root).mm_data.mm_multipart.mm_mp_list)
                     .first
                     .is_null()
@@ -794,7 +795,7 @@ unsafe fn handle_reports(
                         b"disposition-notification\x00" as *const u8 as *const libc::c_char,
                     ) == 0
                 {
-                    if let Ok(report_body) = wrapmime::mailmime_transfer_decode(report_data) {
+                    if let Ok(report_body) = mailmime_transfer_decode(report_data) {
                         let mut report_parsed = std::ptr::null_mut();
                         let mut dummy = 0;
 
@@ -806,14 +807,13 @@ unsafe fn handle_reports(
                         ) == MAIL_NO_ERROR as libc::c_int
                             && !report_parsed.is_null()
                         {
-                            let report_fields =
-                                wrapmime::mailmime_find_mailimf_fields(report_parsed);
+                            let report_fields = mailmime_find_mailimf_fields(report_parsed);
                             if !report_fields.is_null() {
-                                let of_disposition = wrapmime::mailimf_find_optional_field(
+                                let of_disposition = mailimf_find_optional_field(
                                     report_fields,
                                     b"Disposition\x00" as *const u8 as *const libc::c_char,
                                 );
-                                let of_org_msgid = wrapmime::mailimf_find_optional_field(
+                                let of_org_msgid = mailimf_find_optional_field(
                                     report_fields,
                                     b"Original-Message-ID\x00" as *const u8 as *const libc::c_char,
                                 );
@@ -822,16 +822,24 @@ unsafe fn handle_reports(
                                     && !of_org_msgid.is_null()
                                     && !(*of_org_msgid).fld_value.is_null()
                                 {
-                                    if let Ok(rfc724_mid) = wrapmime::parse_message_id(as_str(
+                                    let mut rfc724_mid_0 = std::ptr::null_mut();
+                                    dummy = 0;
+
+                                    if mailimf_msg_id_parse(
                                         (*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,
-                                            &rfc724_mid,
+                                            as_str(rfc724_mid_0),
                                             sent_timestamp,
                                             &mut chat_id_0,
                                             &mut msg_id,
@@ -839,6 +847,7 @@ 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());
                                     }
                                 }
                             }
@@ -1067,7 +1076,7 @@ unsafe fn create_or_lookup_group(
     }
 
     if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Name") {
-        grpname = Some(dc_decode_header_words(&optional_field));
+        grpname = Some(dc_decode_header_words_safe(&optional_field));
     }
     if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Member-Removed") {
         X_MrRemoveFromGrp = Some(optional_field);
@@ -1481,7 +1490,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: &[u32]) -> String {
+fn create_adhoc_grp_id(context: &Context, member_ids: &Vec<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
@@ -1593,7 +1602,7 @@ fn check_verified_properties(
     context: &Context,
     mimeparser: &MimeParser,
     from_id: u32,
-    to_ids: &[u32],
+    to_ids: &Vec<u32>,
 ) -> Result<()> {
     let contact = Contact::load_from_db(context, from_id)?;
 
@@ -1661,7 +1670,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)?;
+                    peerstate.save_to_db(&context.sql, false).unwrap();
                     is_verified = true;
                 }
             }
@@ -1713,13 +1722,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()
-                && is_known_rfc724_mid_in_list(
+            if !fld_references.is_null() {
+                if is_known_rfc724_mid_in_list(
                     context,
                     (*(*field).fld_data.fld_references).mid_list,
-                )
-            {
-                return 1;
+                ) {
+                    return 1;
+                }
             }
         }
     }
@@ -1733,12 +1742,12 @@ unsafe fn is_known_rfc724_mid_in_list(context: &Context, mid_list: *const clist)
     }
 
     for data in &*mid_list {
-        if is_known_rfc724_mid(context, data.cast()) != 0 {
+        if 0 != is_known_rfc724_mid(context, data.cast()) {
             return true;
         }
     }
 
-    false
+    return false;
 }
 
 /// Check if a message is a reply to a known message (messenger or non-messenger).
@@ -1956,15 +1965,17 @@ 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 = dc_decode_header_words(as_str(display_name_enc));
+        let tmp = as_str(dc_decode_header_words(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 && !ids.contains(&row_id) {
-        ids.push(row_id);
+    if 0 != row_id {
+        if !ids.contains(&row_id) {
+            ids.push(row_id);
+        }
     };
 }
 

src/dc_simplify.rs

@@ -10,16 +10,18 @@ pub struct Simplify {
 ///
 /// Also return whether not-standard (rfc3676, §4.3) footer is found.
 fn find_message_footer(lines: &[&str]) -> (usize, bool) {
-    for (ix, &line) in lines.iter().enumerate() {
+    for ix in 0..lines.len() {
+        let line = lines[ix];
+
         // quoted-printable may encode `-- ` to `-- =20` which is converted
         // back to `--  `
-        match line {
+        match line.as_ref() {
             "-- " | "--  " => return (ix, false),
             "--" | "---" | "----" => return (ix, true),
             _ => (),
         }
     }
-    (lines.len(), false)
+    return (lines.len(), false);
 }
 
 impl Simplify {
@@ -101,8 +103,10 @@ impl Simplify {
             if let Some(last_quoted_line) = l_lastQuotedLine {
                 l_last = last_quoted_line;
                 is_cut_at_end = true;
-                if l_last > 1 && is_empty_line(lines[l_last - 1]) {
-                    l_last -= 1
+                if l_last > 1 {
+                    if is_empty_line(lines[l_last - 1]) {
+                        l_last -= 1
+                    }
                 }
                 if l_last > 1 {
                     let line = lines[l_last - 1];
@@ -201,7 +205,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;
+use libc::{free, strlen};
 use mmime::mailmime::decode::mailmime_encoded_phrase_parse;
 use mmime::other::*;
 use percent_encoding::{percent_decode, utf8_percent_encode, AsciiSet, CONTROLS};
@@ -68,7 +68,28 @@ fn quote_word(word: &[u8]) -> String {
  * Encode/decode header words, RFC 2047
  ******************************************************************************/
 
-pub(crate) fn dc_decode_header_words(input: &str) -> String {
+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 {
     static FROM_ENCODING: &[u8] = b"iso-8859-1\x00";
     static TO_ENCODING: &[u8] = b"utf-8\x00";
     let mut out = ptr::null_mut();
@@ -156,31 +177,60 @@ 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() {
-        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(),
-        );
-
-        assert_eq!(dc_decode_header_words("just ascii test"), "just ascii test");
-
-        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(),
-        );
-        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(),
+        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);
+
+            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_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(),
+            );
+            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]
@@ -243,7 +293,7 @@ mod tests {
         #[test]
         fn test_dc_header_roundtrip(input: String) {
             let encoded = dc_encode_header_words(&input);
-            let decoded = dc_decode_header_words(&encoded);
+            let decoded = dc_decode_header_words_safe(&encoded);
 
             assert_eq!(input, decoded);
         }

src/dc_tools.rs

@@ -1,9 +1,8 @@
 //! Some tools and enhancements to the used libraries, there should be
 //! no references to Context and other "larger" entities here.
 
-use core::cmp::max;
 use std::borrow::Cow;
-use std::ffi::{CStr, CString};
+use std::ffi::{CStr, CString, OsString};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::SystemTime;
@@ -141,7 +140,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], ellipse))
+            Cow::Owned(format!("{}{}", &buf[..index + 1], ellipse))
         } else {
             Cow::Owned(format!("{}{}", &buf[..end_pos], ellipse))
         }
@@ -334,14 +333,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(b'A')); // Remove last "A"
+    assert_eq!(wrapped_writer.pop(), Some('A' as u8)); // 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: &[u32],
+    contact_ids_to: &Vec<u32>,
 ) -> Option<String> {
     if contact_ids_to.is_empty() {
         return None;
@@ -416,41 +415,12 @@ pub(crate) fn dc_ensure_no_slash_safe(path: &str) -> &str {
     path
 }
 
-// Function returns a sanitized basename that does not contain
-// win/linux path separators and also not any non-ascii chars
-fn get_safe_basename(filename: &str) -> String {
-    // return the (potentially mangled) basename of the input filename
-    // this might be a path that comes in from another operating system
-    let mut index: usize = 0;
-
-    if let Some(unix_index) = filename.rfind('/') {
-        index = unix_index + 1;
-    }
-    if let Some(win_index) = filename.rfind('\\') {
-        index = max(index, win_index + 1);
-    }
-    if index >= filename.len() {
-        "nobasename".to_string()
-    } else {
-        // we don't allow any non-ascii to be super-safe
-        filename[index..].replace(|c: char| !c.is_ascii() || c == ':', "-")
-    }
-}
-
-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('.') {
-        (
-            basename[0..index].to_string(),
-            basename[index..].to_string(),
-        )
-    } else {
-        (basename, "".to_string())
-    };
-    // limit length of stem and ext
-    stem.truncate(32);
-    ext.truncate(32);
-    (stem, ext)
+/// Function modifies the given buffer and replaces all characters not valid in filenames by a "-".
+fn validate_filename(filename: &str) -> String {
+    filename
+        .replace('/', "-")
+        .replace('\\', "-")
+        .replace(':', "-")
 }
 
 // the returned suffix is lower-case
@@ -596,24 +566,49 @@ pub fn dc_read_file<P: AsRef<std::path::Path>>(
     }
 }
 
-pub(crate) fn dc_get_next_backup_path(
+pub(crate) fn dc_get_fine_path_filename(
+    context: &Context,
     folder: impl AsRef<Path>,
-    backup_time: i64,
-) -> Result<PathBuf, Error> {
-    let folder = PathBuf::from(folder.as_ref());
-    let stem = chrono::NaiveDateTime::from_timestamp(backup_time, 0)
-        .format("delta-chat-%Y-%m-%d")
-        .to_string();
+    desired_filename_suffix: impl AsRef<str>,
+) -> PathBuf {
+    let now = time();
 
-    // 64 backup files per day should be enough for everyone
-    for i in 0..64 {
-        let mut path = folder.clone();
-        path.push(format!("{}-{}.bak", stem, i));
-        if !path.exists() {
-            return Ok(path);
+    let folder = PathBuf::from(folder.as_ref());
+    // XXX sanitize desired_filename eg using
+    // https://github.com/kardeiz/sanitize-filename/blob/master/src/lib.rs
+    let suffix = validate_filename(desired_filename_suffix.as_ref());
+    let file_name = PathBuf::from(suffix);
+    let extension = file_name.extension().map(|c| c.clone());
+
+    for i in 0..100_000 {
+        let ret = if i == 0 {
+            let mut folder = folder.clone();
+            folder.push(&file_name);
+            folder
+        } else {
+            let idx = if i < 100 { i } else { now + i };
+            let file_name = if let Some(stem) = file_name.file_stem() {
+                let mut stem = stem.to_os_string();
+                stem.push(format!("-{}", idx));
+                stem
+            } else {
+                OsString::from(idx.to_string())
+            };
+            let mut folder = folder.clone();
+            folder.push(file_name);
+            if let Some(ext) = extension {
+                folder.set_extension(&ext);
+            }
+            folder
+        };
+
+        if !dc_file_exist(context, &ret) {
+            // fine filename found
+            return ret;
         }
     }
-    bail!("could not create backup file, disk full?");
+
+    panic!("Something is really wrong, you need to clean up your disk");
 }
 
 pub(crate) fn dc_is_blobdir_path(context: &Context, path: impl AsRef<str>) -> bool {
@@ -641,10 +636,13 @@ pub(crate) fn dc_make_rel_and_copy(context: &Context, path: &mut String) -> bool
         dc_make_rel_path(context, path);
         return true;
     }
-    if let Ok(blobdir_path) = context.copy_to_blobdir(&path) {
-        *path = blobdir_path;
+    let blobdir_path = dc_get_fine_path_filename(context, "$BLOBDIR", &path);
+    if dc_copy_file(context, &path, &blobdir_path) {
+        *path = blobdir_path.to_string_lossy().to_string();
+        dc_make_rel_path(context, path);
         return true;
     }
+
     false
 }
 
@@ -1439,19 +1437,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_file_get_safe_basename() {
-        assert_eq!(get_safe_basename("12312/hello"), "hello");
-        assert_eq!(get_safe_basename("12312\\hello"), "hello");
-        assert_eq!(get_safe_basename("//12312\\hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12\\hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12/\\\\hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12//hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12//"), "nobasename");
-        assert_eq!(get_safe_basename("//123:12/"), "nobasename");
-        assert!(get_safe_basename("123\x012.hello").ends_with(".hello"));
-    }
-
     #[test]
     fn test_file_handling() {
         let t = dummy_context();
@@ -1486,7 +1471,6 @@ mod tests {
         assert!(dc_file_exist(context, &abs_path));
 
         assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
-
         assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada",), 7);
 
         let buf = dc_read_file(context, "$BLOBDIR/dada").unwrap();
@@ -1499,12 +1483,14 @@ mod tests {
         assert!(dc_create_folder(context, "$BLOBDIR/foobar-folder"));
         assert!(dc_file_exist(context, "$BLOBDIR/foobar-folder",));
         assert!(!dc_delete_file(context, "$BLOBDIR/foobar-folder"));
+        let fn0 = dc_get_fine_path_filename(context, "$BLOBDIR", "foobar.dadada");
+        assert_eq!(fn0, PathBuf::from("$BLOBDIR/foobar.dadada"));
 
-        let fn0 = "$BLOBDIR/data.data";
         assert!(dc_write_file(context, &fn0, b"content"));
+        let fn1 = dc_get_fine_path_filename(context, "$BLOBDIR", "foobar.dadada");
+        assert_eq!(fn1, PathBuf::from("$BLOBDIR/foobar-1.dadada"));
 
         assert!(dc_delete_file(context, &fn0));
-        assert!(!dc_file_exist(context, &fn0));
     }
 
     #[test]

src/e2ee.rs

@@ -22,6 +22,7 @@ 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::*;
@@ -46,8 +47,12 @@ pub struct EncryptHelper {
 
 impl EncryptHelper {
     pub fn new(context: &Context) -> Result<EncryptHelper> {
-        let prefer_encrypt =
-            EncryptPreference::from_i32(context.get_config_int(Config::E2eeEnabled)).unwrap();
+        let prefer_encrypt = context
+            .sql
+            .get_config_int(&context, "e2ee_enabled")
+            .and_then(EncryptPreference::from_i32)
+            .unwrap_or_default();
+
         let addr = match context.get_config(Config::ConfiguredAddr) {
             None => {
                 bail!("addr not configured!");
@@ -261,80 +266,103 @@ 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 = unsafe { 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();
 
-    let self_addr = context.get_config(Config::ConfiguredAddr);
+    // 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();
 
-    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);
+    // 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()
                 }
             }
+        }
+        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);
 
-            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 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)?;
+                }
             }
         }
     }
+    if !gossip_headers.is_null() {
+        unsafe { mailimf_fields_free(gossip_headers) };
+    }
+
     Ok((encrypted, signatures, gossipped_addr))
 }
 
@@ -532,7 +560,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.is_empty() {
+        if (*ret_gossip_headers).is_null() && ret_valid_signatures.len() > 0 {
             let mut dummy: libc::size_t = 0;
             let mut test: *mut mailimf_fields = ptr::null_mut();
             if mailimf_envelope_and_optional_fields_parse(
@@ -572,16 +600,22 @@ fn decrypt_part(
         mime_transfer_encoding = enc;
     }
 
-    let data: Vec<u8> = wrapmime::decode_dt_data(mime_data, mime_transfer_encoding)?;
+    let (decoded_data, decoded_data_bytes) =
+        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();
 
-    if has_decrypted_pgp_armor(&data) {
+    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) {
         // 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),
@@ -590,7 +624,10 @@ fn decrypt_part(
                 ensure!(!ret_valid_signatures.is_empty(), "no valid signatures");
                 plain
             }
-            Err(err) => bail!("could not decrypt: {}", err),
+            Err(err) => {
+                unsafe { mmap_string_unref(decoded_data) };
+                bail!("could not decrypt: {}", err)
+            }
         };
         let plain_bytes = plain.len();
         let plain_buf = plain.as_ptr() as *const libc::c_char;
@@ -618,6 +655,7 @@ fn decrypt_part(
             ret_decrypted_mime = decrypted_mime;
         }
     }
+    unsafe { mmap_string_unref(decoded_data) };
 
     Ok(ret_decrypted_mime)
 }
@@ -685,12 +723,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_else(|| {
-        format_err!(concat!(
+    let self_addr = context
+        .get_config(Config::ConfiguredAddr)
+        .ok_or(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,18 +42,6 @@ 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),
-
     /// The library-user should write a warning string to the log.
     /// Passed to the callback given to dc_context_new().
     ///

src/imap.rs

@@ -8,14 +8,12 @@ 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::{connect_to_inbox, job_add, Action};
-use crate::login_param::{dc_build_tls, CertificateChecks, LoginParam};
+use crate::job::{job_add, Action};
+use crate::login_param::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;
 
@@ -29,6 +27,7 @@ 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 {
@@ -108,10 +107,14 @@ 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 = dc_build_tls(certificate_checks).unwrap();
+        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 s = stream.try_clone().expect("cloning the stream failed");
         let tls_stream = native_tls::TlsConnector::connect(&tls, domain.as_ref(), s)?;
@@ -131,14 +134,13 @@ impl Client {
         Ok(Client::Insecure(client, stream))
     }
 
-    pub fn secure<S: AsRef<str>>(
-        self,
-        domain: S,
-        certificate_checks: CertificateChecks,
-    ) -> imap::error::Result<Client> {
+    pub fn secure<S: AsRef<str>>(self, domain: S) -> imap::error::Result<Client> {
         match self {
             Client::Insecure(client, stream) => {
-                let tls = dc_build_tls(certificate_checks).unwrap();
+                let tls = native_tls::TlsConnector::builder()
+                    .danger_accept_invalid_hostnames(true)
+                    .build()
+                    .unwrap();
 
                 let client_sec = client.secure(domain, &tls)?;
 
@@ -318,7 +320,6 @@ 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>,
@@ -331,13 +332,12 @@ struct ImapConfig {
 
 impl Default for ImapConfig {
     fn default() -> Self {
-        ImapConfig {
+        let cfg = 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,7 +346,9 @@ impl Default for ImapConfig {
             has_xlist: false,
             imap_delimiter: '.',
             watch_folder: None,
-        }
+        };
+
+        cfg
     }
 }
 
@@ -394,7 +396,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, config.certificate_checks)
+                        client.secure(imap_server)
                     } else {
                         Ok(client)
                     }
@@ -404,11 +406,7 @@ 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,
-                    config.certificate_checks,
-                )
+                Client::connect_secure((imap_server, imap_port), imap_server)
             };
 
         let login_res = match connection_res {
@@ -535,7 +533,6 @@ 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;
         }
 
@@ -684,7 +681,7 @@ impl Imap {
                     }
                 }
             } else {
-                unreachable!();
+                return 0;
             }
         }
 
@@ -819,7 +816,11 @@ impl Imap {
             if cur_uid > last_seen_uid {
                 read_cnt += 1;
 
-                let message_id = prefetch_get_message_id(msg).unwrap_or_default();
+                let message_id = msg
+                    .envelope()
+                    .expect("missing envelope")
+                    .message_id
+                    .expect("missing message id");
 
                 if !precheck_imf(context, &message_id, folder.as_ref(), cur_uid) {
                     // check passed, go fetch the rest
@@ -932,15 +933,22 @@ impl Imap {
         } else {
             let msg = &msgs[0];
 
-            // 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 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();
 
             let flags = if is_seen { DC_IMAP_SEEN } else { 0 };
 
@@ -1111,94 +1119,117 @@ impl Imap {
         cvar.notify_one();
     }
 
-    pub fn mv(
+    pub fn mv<S1: AsRef<str>, S2: AsRef<str>>(
         &self,
         context: &Context,
-        folder: &str,
+        folder: S1,
         uid: u32,
-        dest_folder: &str,
+        dest_folder: S2,
         dest_uid: &mut u32,
     ) -> ImapResult {
-        if folder == dest_folder {
+        let mut res = ImapResult::RetryLater;
+        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, uid, dest_folder,
+                "Skip moving message; message {}/{} is already in {}...",
+                folder.as_ref(),
+                uid,
+                dest_folder.as_ref()
             );
-            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);
-        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
-                    );
-                }
-            }
+            res = ImapResult::AlreadyDone;
         } else {
-            unreachable!();
-        };
+            info!(
+                context,
+                "Moving message {}/{} to {}...",
+                folder.as_ref(),
+                uid,
+                dest_folder.as_ref()
+            );
 
-        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
+            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;
-                        ImapResult::Success
+                        res = ImapResult::Success;
                     }
                 }
-                Err(err) => {
-                    warn!(context, "Could not copy message: {}", err);
-                    ImapResult::Failed
-                }
+            }
+        }
+
+        if res == ImapResult::Success {
+            // TODO: is this correct?
+            *dest_uid = uid;
+        }
+
+        if res == ImapResult::RetryLater {
+            if self.should_reconnect() {
+                ImapResult::RetryLater
+            } else {
+                ImapResult::Failed
             }
         } else {
-            unreachable!();
+            res
         }
     }
 
-    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.
+    fn add_flag<S: AsRef<str>>(&self, context: &Context, server_uid: u32, flag: S) -> usize {
         if server_uid == 0 {
-            return true; // might be moved but we don't want to have a stuck job
-        }
-        if self.should_reconnect() {
-            return false;
+            return 0;
         }
         if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
             let set = format!("{}", server_uid);
-            let query = format!("+FLAGS ({})", flag);
+            let query = format!("+FLAGS ({})", flag.as_ref());
             match session.uid_store(&set, &query) {
                 Ok(_) => {}
                 Err(err) => {
@@ -1208,126 +1239,243 @@ impl Imap {
                     );
                 }
             }
-            true // we tried once, that's probably enough for setting flag
+        }
+
+        // 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
         } else {
-            unreachable!();
+            1
         }
     }
 
-    pub fn prepare_imap_operation_on_msg(
-        &self,
-        context: &Context,
-        folder: &str,
-        uid: u32,
-    ) -> Option<ImapResult> {
+    pub fn set_seen<S: AsRef<str>>(&self, context: &Context, folder: S, uid: u32) -> ImapResult {
+        let mut res = ImapResult::RetryLater;
+
         if uid == 0 {
-            return Some(ImapResult::Failed);
-        } else if !self.is_connected() {
-            connect_to_inbox(context, &self);
-            if !self.is_connected() {
-                return Some(ImapResult::RetryLater);
+            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
             }
         }
-        if self.select_folder(context, Some(&folder)) == 0 {
-            warn!(
-                context,
-                "Cannot select folder {} for preparing IMAP operation", folder
-            );
-            Some(ImapResult::RetryLater)
+
+        if res == ImapResult::RetryLater {
+            if self.should_reconnect() {
+                ImapResult::RetryLater
+            } else {
+                ImapResult::Failed
+            }
         } else {
-            None
+            res
         }
     }
 
-    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,);
+    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 self.add_flag_finalized(context, uid, "\\Seen") {
-            ImapResult::Success
-        } else {
-            warn!(
+        if uid == 0 {
+            res = ImapResult::Failed;
+        } else if self.is_connected() {
+            info!(
                 context,
-                "Cannot mark message {} in folder {} as seen, ignoring.", uid, folder
+                "Marking message {}/{} as $MDNSent...",
+                folder.as_ref(),
+                uid,
             );
-            ImapResult::Failed
+
+            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.",
+                    );
+                }
+            }
+        }
+
+        if res == ImapResult::RetryLater {
+            if self.should_reconnect() {
+                ImapResult::RetryLater
+            } else {
+                ImapResult::Failed
+            }
+        } else {
+            res
         }
     }
 
     // only returns 0 on connection problems; we should try later again in this case *
-    pub fn delete_msg(
+    pub fn delete_msg<S1: AsRef<str>, S2: AsRef<str>>(
         &self,
         context: &Context,
-        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
+        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,
+            );
 
-        let set = format!("{}", uid);
-        let display_imap_id = format!("{}/{}", folder, uid);
+            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);
 
-        // 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;
+                            warn!(
+                                context,
+                                "Cannot delete on IMAP, {}/{} not found.",
+                                folder.as_ref(),
+                                server_uid,
+                            );
+                            *server_uid = 0;
+                        }
                     }
-                    let remote_message_id =
-                        prefetch_get_message_id(msgs.first().unwrap()).unwrap_or_default();
-
-                    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;
+
+                // 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
                 }
             }
         }
 
-        // 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
+        if success {
+            1
         } else {
-            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
+            self.is_connected() as usize
         }
     }
 
@@ -1487,11 +1635,27 @@ 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,
@@ -1499,21 +1663,8 @@ 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);
         }
-
-        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)
+    rfc724_mid_exists
 }

src/imex.rs

@@ -129,15 +129,14 @@ pub fn initiate_key_transfer(context: &Context) -> Result<String> {
                 .unwrap()
                 .shall_stop_ongoing
             {
-                let setup_file_name = context.new_blob_file(
-                    "autocrypt-setup-message.html",
-                    setup_file_content.as_bytes(),
-                )?;
-                {
+                let setup_file_name =
+                    dc_get_fine_path_filename(context, "$BLOBDIR", "autocrypt-setup-message.html");
+                if dc_write_file(context, &setup_file_name, setup_file_content.as_bytes()) {
                     if let Ok(chat_id) = chat::create_by_contact_id(context, 1) {
                         msg = Message::default();
                         msg.type_0 = Viewtype::File;
-                        msg.param.set(Param::File, setup_file_name);
+                        msg.param
+                            .set(Param::File, setup_file_name.to_string_lossy());
 
                         msg.param
                             .set(Param::MimeType, "application/autocrypt-setup");
@@ -195,9 +194,13 @@ 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.get_config_bool(Config::E2eeEnabled) {
-        false => None,
-        true => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
+    let ac_headers = match context
+        .sql
+        .get_config_int(context, Config::E2eeEnabled)
+        .unwrap_or(1)
+    {
+        0 => None,
+        _ => 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())?;
@@ -474,7 +477,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()),
@@ -511,7 +514,9 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
             Ok((name, blob))
         },
         |files| {
-            for (processed_files_cnt, file) in files.enumerate() {
+            let mut processed_files_cnt = 0;
+
+            for file in files {
                 let (file_name, file_blob) = file?;
                 if context
                     .running_state
@@ -522,6 +527,7 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
                 {
                     bail!("received stop signal");
                 }
+                processed_files_cnt += 1;
                 let mut permille = processed_files_cnt * 1000 / total_files_cnt;
                 if permille < 10 {
                     permille = 10
@@ -567,10 +573,13 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
 
     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);
+    // FIXME: we should write to a temporary file first and rename it on success. this would guarantee the backup is complete. however, currently it is not clear it the import exists in the long run (may be replaced by a restore-from-imap)
     let now = time();
-    let dest_path_filename = dc_get_next_backup_path(dir, now)?;
+    let res = chrono::NaiveDateTime::from_timestamp(now as i64, 0)
+        .format("delta-chat-%Y-%m-%d.bak")
+        .to_string();
+
+    let dest_path_filename = dc_get_fine_path_filename(context, dir, res);
 
     sql::housekeeping(context);
 
@@ -801,7 +810,7 @@ fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
             "No private keys found in \"{}\".",
             dir_name
         );
-        Ok(())
+        return Ok(());
     } else {
         bail!("Import: Cannot open directory \"{}\".", dir_name);
     }

src/job.rs

@@ -4,12 +4,10 @@ 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::*;
@@ -142,11 +140,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) => {
-                                warn!(context, "invalid recipient: {} {:?}", addr, err);
+                                eprintln!("WARNING: invalid recipient: {} {:?}", addr, err);
                                 None
                             }
                         })
@@ -158,45 +156,39 @@ impl Job {
                     if 0 != self.foreign_id && !message::exists(context, self.foreign_id) {
                         warn!(
                             context,
-                            "Not sending Message {} as it was deleted", self.foreign_id
+                            "Message {} for job {} does not exist", self.foreign_id, self.job_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 ASAP as we
+                    // was sent we need to mark it in the database as we
                     // otherwise might send it twice.
                     let mut sock = context.smtp.lock().unwrap();
-                    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(
+                    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(
                                     context,
-                                    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);
+                                    "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,
+                            });
                         }
                     }
                 } else {
@@ -216,6 +208,13 @@ 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
@@ -262,18 +261,26 @@ 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 */
-                if message::rfc724_mid_cnt(context, &msg.rfc724_mid) > 1 {
+                let mut delete_from_server = true;
+                if message::rfc724_mid_cnt(context, &msg.rfc724_mid) != 1 {
                     info!(
                         context,
                         "The message is deleted from the server when all parts are deleted.",
                     );
-                } else {
-                    /* if this is the last existing part of the message,
-                    we delete the message from the server */
+                    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;
+                        }
+                    }
                     let mid = msg.rfc724_mid;
                     let server_folder = msg.server_folder.as_ref().unwrap();
-                    let res = inbox.delete_msg(context, &mid, server_folder, &mut msg.server_uid);
-                    if res == ImapResult::RetryLater {
+                    if 0 == inbox.delete_msg(context, &mid, server_folder, &mut msg.server_uid) {
                         self.try_again_later(-1i32, None);
                         return;
                     }
@@ -287,23 +294,37 @@ 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 folder = msg.server_folder.as_ref().unwrap();
-            match inbox.set_seen(context, folder, msg.server_uid) {
+            let server_folder = msg.server_folder.as_ref().unwrap();
+            match inbox.set_seen(context, server_folder, msg.server_uid) {
+                ImapResult::Failed => {}
                 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()
-                        && context.get_config_bool(Config::MdnsEnabled)
+                        && 0 != context
+                            .sql
+                            .get_config_int(context, "mdns_enabled")
+                            .unwrap_or_else(|| 1)
                     {
-                        if let Err(err) = send_mdn(context, msg.id) {
-                            warn!(context, "could not send out mdn for {}: {}", msg.id, err);
+                        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 => {}
                         }
                     }
                 }
@@ -320,9 +341,16 @@ 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.set_seen(context, &folder, uid) == ImapResult::RetryLater {
+
+        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 {
             self.try_again_later(3i32, None);
-            return;
         }
         if 0 != self.param.get_int(Param::AlsoMove).unwrap_or_default() {
             if context
@@ -337,7 +365,7 @@ impl Job {
             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);
                 }
@@ -573,108 +601,109 @@ 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) -> Result<(), Error> {
-    let mut mimefactory = MimeFactory::load_msg(context, msg_id)?;
+pub fn job_send_msg(context: &Context, msg_id: u32) -> libc::c_int {
+    let mut success = 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::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));
-        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() {
+    /* load message data */
+    let mimefactory = MimeFactory::load_msg(context, msg_id);
+    if mimefactory.is_err() {
         warn!(
             context,
-            "message {} has no recipient, skipping smtp-send", msg_id
+            "Cannot load data to send, maybe the message is deleted in between.",
         );
-        return Ok(());
-    }
+    } 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 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 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
+            {
+                mimefactory.msg.param.set_int(Param::GuranteeE2ee, 1);
+                mimefactory.msg.save_param_to_disk(context);
+            }
+            success = add_smtp_job(context, Action::SendMsgToSmtp, &mut mimefactory);
+        }
     }
-    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(())
+    success
 }
 
 pub fn perform_imap_jobs(context: &Context) {
@@ -764,13 +793,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()
@@ -895,7 +924,8 @@ 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 N = 2_i32.pow((c_tries - 1) as u32) * 60;
+    let mut N = 2_i32.pow((c_tries - 1) as u32);
+    N = N * 60;
     let mut rng = thread_rng();
     let n: i32 = rng.gen();
     let mut seconds = n % (N + 1);
@@ -917,7 +947,7 @@ fn suspend_smtp_thread(context: &Context, suspend: bool) {
     }
 }
 
-pub fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
+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());
@@ -925,45 +955,51 @@ pub fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
     ret_connected
 }
 
-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(())
+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);
+        }
+    }
 }
 
 #[allow(non_snake_case)]
-fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) -> Result<(), Error> {
-    ensure!(
-        !mimefactory.recipients_addr.is_empty(),
-        "no recipients for smtp job set"
-    );
+fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) -> libc::c_int {
+    let mut success: libc::c_int = 0i32;
     let mut param = Params::new();
+    let path_filename = dc_get_fine_path_filename(context, "$BLOBDIR", &mimefactory.rfc724_mid);
     let bytes = unsafe {
         std::slice::from_raw_parts(
             (*mimefactory.out).str_0 as *const u8,
             (*mimefactory.out).len,
         )
     };
-    let bpath = context.new_blob_file(&mimefactory.rfc724_mid, bytes)?;
-    info!(context, "add_smtp_job file written: {:?}", bpath);
-    let recipients = mimefactory.recipients_addr.join("\x1e");
-    param.set(Param::File, &bpath);
-    param.set(Param::Recipients, &recipients);
-    job_add(
-        context,
-        action,
-        (if mimefactory.loaded == Loaded::Message {
-            mimefactory.msg.id
-        } else {
-            0
-        }) as libc::c_int,
-        param,
-        0,
-    );
-
-    Ok(())
+    if !dc_write_file(context, &path_filename, bytes) {
+        error!(
+            context,
+            "Could not write message <{}> to \"{}\".",
+            mimefactory.rfc724_mid,
+            path_filename.display(),
+        );
+    } else {
+        info!(context, "add_smtp_job file written: {:?}", path_filename);
+        let recipients = mimefactory.recipients_addr.join("\x1e");
+        param.set(Param::File, path_filename.to_string_lossy());
+        param.set(Param::Recipients, &recipients);
+        job_add(
+            context,
+            action,
+            (if mimefactory.loaded == Loaded::Message {
+                mimefactory.msg.id
+            } else {
+                0
+            }) as libc::c_int,
+            param,
+            0,
+        );
+        success = 1;
+    }
+    success
 }
 
 pub fn job_add(

src/key.rs

@@ -218,10 +218,10 @@ impl Key {
         let file_content = self.to_asc(None).into_bytes();
 
         if dc_write_file(context, &file, &file_content) {
-            true
+            return true;
         } else {
             error!(context, "Cannot write key to {}", file.as_ref().display());
-            false
+            return false;
         }
     }
 

src/location.rs

@@ -62,7 +62,7 @@ impl Kml {
 
     pub fn parse(context: &Context, content: impl AsRef<str>) -> Result<Self, Error> {
         ensure!(
-            content.as_ref().len() <= (1024 * 1024),
+            content.as_ref().len() <= (1 * 1024 * 1024),
             "A kml-files with {} bytes is larger than reasonably expected.",
             content.as_ref().len()
         );
@@ -359,7 +359,7 @@ pub fn get_range(
 }
 
 fn is_marker(txt: &str) -> bool {
-    txt.len() == 1 && !txt.starts_with(' ')
+    txt.len() == 1 && txt.chars().next().unwrap() != ' '
 }
 
 pub fn delete_all(context: &Context) -> Result<(), Error> {

src/login_param.rs

@@ -4,22 +4,6 @@ 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,
@@ -27,14 +11,10 @@ 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,
 }
 
@@ -68,14 +48,6 @@ impl LoginParam {
         let key = format!("{}mail_pw", prefix);
         let mail_pw = sql.get_config(context, key).unwrap_or_default();
 
-        let key = format!("{}imap_certificate_checks", prefix);
-        let imap_certificate_checks =
-            if let Some(certificate_checks) = sql.get_config_int(context, key) {
-                num_traits::FromPrimitive::from_i32(certificate_checks).unwrap_or_default()
-            } else {
-                Default::default()
-            };
-
         let key = format!("{}send_server", prefix);
         let send_server = sql.get_config(context, key).unwrap_or_default();
 
@@ -88,14 +60,6 @@ impl LoginParam {
         let key = format!("{}send_pw", prefix);
         let send_pw = sql.get_config(context, key).unwrap_or_default();
 
-        let key = format!("{}smtp_certificate_checks", prefix);
-        let smtp_certificate_checks =
-            if let Some(certificate_checks) = sql.get_config_int(context, key) {
-                num_traits::FromPrimitive::from_i32(certificate_checks).unwrap_or_default()
-            } else {
-                Default::default()
-            };
-
         let key = format!("{}server_flags", prefix);
         let server_flags = sql.get_config_int(context, key).unwrap_or_default();
 
@@ -105,12 +69,10 @@ impl LoginParam {
             mail_user,
             mail_pw,
             mail_port,
-            imap_certificate_checks,
             send_server,
             send_user,
             send_pw,
             send_port,
-            smtp_certificate_checks,
             server_flags,
         }
     }
@@ -143,9 +105,6 @@ impl LoginParam {
         let key = format!("{}mail_pw", prefix);
         sql.set_config(context, key, Some(&self.mail_pw))?;
 
-        let key = format!("{}imap_certificate_checks", prefix);
-        sql.set_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))?;
 
@@ -158,9 +117,6 @@ impl LoginParam {
         let key = format!("{}send_pw", prefix);
         sql.set_config(context, key, Some(&self.send_pw))?;
 
-        let key = format!("{}smtp_certificate_checks", prefix);
-        sql.set_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)?;
 
@@ -177,18 +133,16 @@ 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,
         )
     }
@@ -250,41 +204,3 @@ 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

@@ -494,10 +494,12 @@ impl Lot {
                     } else {
                         self.text1 = None;
                     }
-                } else if let Some(contact) = contact {
-                    self.text1 = Some(contact.get_first_name().into());
                 } else {
-                    self.text1 = None;
+                    if let Some(contact) = contact {
+                        self.text1 = Some(contact.get_first_name().into());
+                    } else {
+                        self.text1 = None;
+                    }
                 }
                 self.text1_meaning = Meaning::Text1Username;
             }
@@ -616,8 +618,9 @@ pub fn get_msg_info(context: &Context, msg_id: u32) -> String {
     }
 
     ret += "\n";
-    if let Some(err) = msg.param.get(Param::Error) {
-        ret += &format!("Error: {}", err)
+    match msg.param.get(Param::Error) {
+        Some(err) => ret += &format!("Error: {}", err),
+        _ => {}
     }
 
     if let Some(path) = msg.get_file(context) {
@@ -685,7 +688,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.iter() {
+    for msg_id in msg_ids.into_iter() {
         update_msg_chat_id(context, *msg_id, DC_CHAT_ID_TRASH);
         job_add(
             context,
@@ -725,7 +728,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.iter() {
+            for id in msg_ids.into_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()))
                 });
@@ -795,7 +798,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.iter() {
+            for msg_id in msg_ids.into_iter() {
                 stmt.execute(params![star as i32, *msg_id as i32])?;
             }
             Ok(())
@@ -815,7 +818,6 @@ 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 => {
@@ -834,7 +836,7 @@ pub fn get_summarytext_by_raw(
                 } else {
                     None
                 }
-                .unwrap_or_else(|| "ErrFileName".to_string());
+                .unwrap_or("ErrFileName".to_string());
 
                 let label = context.stock_str(if viewtype == Viewtype::Audio {
                     StockMessage::Audio

src/mimefactory.rs

@@ -13,11 +13,10 @@ 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::SystemMessage;
+use crate::dc_mimeparser::{mailmime_find_mailimf_fields, SystemMessage};
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
 use crate::e2ee::*;
@@ -107,10 +106,15 @@ impl<'a> MimeFactory<'a> {
     }
 
     pub fn load_mdn(context: &'a Context, msg_id: u32) -> Result<MimeFactory, Error> {
-        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")
+        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 ")
         }
 
         let msg = Message::load_from_db(context, msg_id)?;
@@ -137,35 +141,52 @@ impl<'a> MimeFactory<'a> {
     }
 
     /*******************************************************************************
-     * Render a basic email
+     * Render
      ******************************************************************************/
-    // XXX restrict unsafe to parts, introduce wrapmime helpers where appropriate
+    // 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);
 
-        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(),
+        /* 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(),
                     ),
-                    ptr::null_mut(),
-                ),
-            );
+                );
+            }
         }
         let references_list = if !self.references.is_empty() {
             dc_str_to_clist(&self.references, " ")
@@ -177,7 +198,6 @@ 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,
@@ -382,8 +402,15 @@ impl<'a> MimeFactory<'a> {
                                     &fingerprint,
                                 );
                             }
-                            if let Some(id) = msg.param.get(Param::Arg4) {
-                                wrapmime::new_custom_field(imf_fields, "Secure-Join-Group", &id);
+                            match msg.param.get(Param::Arg4) {
+                                Some(id) => {
+                                    wrapmime::new_custom_field(
+                                        imf_fields,
+                                        "Secure-Join-Group",
+                                        &id,
+                                    );
+                                }
+                                None => {}
                             };
                         }
                     }
@@ -408,10 +435,6 @@ 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
@@ -571,6 +594,7 @@ 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.
@@ -621,7 +645,7 @@ impl<'a> MimeFactory<'a> {
         );
 
         /*just a pointer into mailmime structure, must not be freed*/
-        let imffields_unprotected = wrapmime::mailmime_find_mailimf_fields(message);
+        let imffields_unprotected = mailmime_find_mailimf_fields(message);
         ensure!(
             !imffields_unprotected.is_null(),
             "could not find mime fields"
@@ -633,18 +657,17 @@ impl<'a> MimeFactory<'a> {
             let aheader = encrypt_helper.get_aheader().to_string();
             wrapmime::new_custom_field(imffields_unprotected, "Autocrypt", &aheader);
         }
-        let finalized = if force_plaintext == 0 {
-            encrypt_helper.try_encrypt(
+        let mut finalized = false;
+        if force_plaintext == 0 {
+            finalized = 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)?;
         }
@@ -716,7 +739,10 @@ impl<'a> MimeFactory<'a> {
             }
             if command != SystemMessage::AutocryptSetupMessage
                 && command != SystemMessage::SecurejoinMessage
-                && context.get_config_bool(Config::MdnsEnabled)
+                && 0 != context
+                    .sql
+                    .get_config_int(context, "mdns_enabled")
+                    .unwrap_or_else(|| 1)
             {
                 factory.req_mdn = true;
             }
@@ -905,7 +931,7 @@ fn build_body_file(
     }
 }
 
-pub(crate) fn vec_contains_lowercase(vec: &[String], part: &str) -> bool {
+pub(crate) fn vec_contains_lowercase(vec: &Vec<String>, part: &str) -> bool {
     let partlc = part.to_lowercase();
     for cur in vec.iter() {
         if cur.to_lowercase() == partlc {

src/oauth2.rs

@@ -207,8 +207,14 @@ pub fn dc_get_oauth2_addr(
     addr: impl AsRef<str>,
     code: impl AsRef<str>,
 ) -> Option<String> {
-    let oauth2 = Oauth2::from_address(addr.as_ref())?;
-    oauth2.get_userinfo?;
+    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;
+    }
 
     if let Some(access_token) =
         dc_get_oauth2_access_token(context, addr.as_ref(), code.as_ref(), false)

src/param.rs

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

src/peerstate.rs

@@ -400,8 +400,7 @@ 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,
@@ -417,6 +416,10 @@ impl<'a> Peerstate<'a> {
             )?;
         }
 
+        if self.to_save == Some(ToSave::All) || create {
+            reset_gossiped_timestamp(self.context, 0);
+        }
+
         Ok(())
     }
 
@@ -472,7 +475,7 @@ mod tests {
             "failed to save to db"
         );
 
-        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr)
+        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr.into())
             .expect("failed to load peerstate from db");
 
         // clear to_save, as that is not persissted
@@ -484,44 +487,6 @@ 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();
@@ -555,7 +520,7 @@ mod tests {
             "failed to save"
         );
 
-        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr)
+        let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr.into())
             .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 i32::from(*p1) == '\n' as i32 {
+            if *p1 as libc::c_int == '\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.add(line_chars) = '\n' as i32 as libc::c_char;
+                        *line.offset(line_chars as isize) = '\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()
-        .iter()
+        .into_iter()
         .filter_map(|key| {
             let k: &Key = &key;
             k.try_into().ok()

src/securejoin.rs

@@ -696,7 +696,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.is_empty() {
+    } else if mimeparser.signatures.len() <= 0 {
         warn!(mimeparser.context, "Message not signed.",);
         false
     } else if expected_fingerprint.as_ref().is_empty() {

src/smtp.rs

@@ -3,9 +3,8 @@ use lettre::*;
 
 use crate::constants::*;
 use crate::context::Context;
-use crate::error::Error;
 use crate::events::Event;
-use crate::login_param::{dc_build_tls, LoginParam};
+use crate::login_param::LoginParam;
 use crate::oauth2::*;
 
 #[derive(DebugStub)]
@@ -15,6 +14,7 @@ pub struct Smtp {
     transport_connected: bool,
     /// Email address we are sending from.
     from: Option<EmailAddress>,
+    pub error: Option<String>,
 }
 
 impl Smtp {
@@ -24,6 +24,7 @@ impl Smtp {
             transport: None,
             transport_connected: false,
             from: None,
+            error: None,
         }
     }
 
@@ -68,7 +69,14 @@ impl Smtp {
         let domain = &lp.send_server;
         let port = lp.send_port as u16;
 
-        let tls = dc_build_tls(lp.smtp_certificate_checks).unwrap();
+        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_parameters = ClientTlsParameters::new(domain.to_string(), tls);
 
         let creds = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
@@ -117,50 +125,37 @@ 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>,
-        message: Vec<u8>,
-    ) -> Result<(), Error> {
-        let message_len = message.len();
-
-        let recipients_display = recipients
-            .iter()
-            .map(|x| format!("{}", x))
-            .collect::<Vec<String>>()
-            .join(",");
-
+        body: Vec<u8>,
+    ) -> usize {
         if let Some(ref mut transport) = self.transport {
-            let envelope = Envelope::new(self.from.clone(), recipients);
-            ensure!(envelope.is_ok(), "internal smtp-message construction fail");
-            let envelope = envelope.unwrap();
+            let envelope = Envelope::new(self.from.clone(), recipients).expect("invalid envelope");
             let mail = SendableEmail::new(
                 envelope,
                 "mail-id".into(), // TODO: random id
-                message,
+                body,
             );
 
             match transport.send(mail) {
                 Ok(_) => {
-                    context.call_cb(Event::SmtpMessageSent(format!(
-                        "Message len={} was smtp-sent to {}",
-                        message_len, recipients_display
-                    )));
+                    context.call_cb(Event::SmtpMessageSent(
+                        "Message was sent to SMTP server".into(),
+                    ));
                     self.transport_connected = true;
-                    Ok(())
+                    1
                 }
                 Err(err) => {
-                    bail!("SMTP failed len={}: error: {}", message_len, err);
+                    warn!(context, "SMTP failed to send message: {}", err);
+                    self.error = Some(format!("{}", err));
+                    0
                 }
             }
         } else {
-            bail!(
-                "uh? SMTP has no transport,  failed to send to {:?}",
-                recipients_display
-            );
+            // TODO: log error
+            0
         }
     }
 }

src/sql.rs

@@ -1,6 +1,5 @@
 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;
@@ -69,16 +68,6 @@ 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),
@@ -235,7 +224,7 @@ impl Sql {
             Ok(_) => Ok(()),
             Err(err) => {
                 error!(context, "set_config(): Cannot change value. {:?}", &err);
-                Err(err)
+                Err(err.into())
             }
         }
     }
@@ -341,7 +330,7 @@ fn open(
         .with_init(|c| c.execute_batch("PRAGMA secure_delete=on;"));
     let pool = r2d2::Pool::builder()
         .min_idle(Some(2))
-        .max_size(10)
+        .max_size(4)
         .connection_timeout(std::time::Duration::new(60, 0))
         .build(mgr)?;
 
@@ -493,7 +482,6 @@ 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![],
@@ -506,7 +494,6 @@ fn open(
             sql.set_config_int(context, "dbversion", 1)?;
         }
         if dbversion < 2 {
-            info!(context, "[migration] v2");
             sql.execute(
                 "ALTER TABLE contacts ADD COLUMN authname TEXT DEFAULT '';",
                 params![],
@@ -515,7 +502,6 @@ fn open(
             sql.set_config_int(context, "dbversion", 2)?;
         }
         if dbversion < 7 {
-            info!(context, "[migration] v7");
             sql.execute(
                 "CREATE TABLE keypairs (\
                  id INTEGER PRIMARY KEY, \
@@ -530,7 +516,6 @@ fn open(
             sql.set_config_int(context, "dbversion", 7)?;
         }
         if dbversion < 10 {
-            info!(context, "[migration] v10");
             sql.execute(
                 "CREATE TABLE acpeerstates (\
                  id INTEGER PRIMARY KEY, \
@@ -549,7 +534,6 @@ fn open(
             sql.set_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![],
@@ -562,7 +546,6 @@ fn open(
             sql.set_config_int(context, "dbversion", 12)?;
         }
         if dbversion < 17 {
-            info!(context, "[migration] v17");
             sql.execute(
                 "ALTER TABLE chats ADD COLUMN archived INTEGER DEFAULT 0;",
                 params![],
@@ -577,7 +560,6 @@ fn open(
             sql.set_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![],
@@ -587,7 +569,6 @@ fn open(
             sql.set_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);",
@@ -605,7 +586,6 @@ fn open(
             sql.set_config_int(context, "dbversion", 27)?;
         }
         if dbversion < 34 {
-            info!(context, "[migration] v34");
             sql.execute(
                 "ALTER TABLE msgs ADD COLUMN hidden INTEGER DEFAULT 0;",
                 params![],
@@ -635,7 +615,6 @@ fn open(
             sql.set_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![]
@@ -666,7 +645,6 @@ fn open(
             sql.set_config_int(context, "dbversion", 39)?;
         }
         if dbversion < 40 {
-            info!(context, "[migration] v40");
             sql.execute(
                 "ALTER TABLE jobs ADD COLUMN thread INTEGER DEFAULT 0;",
                 params![],
@@ -675,25 +653,21 @@ fn open(
             sql.set_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)?;
         }
         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)?;
         }
         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)?;
         }
         if dbversion < 46 {
-            info!(context, "[migration] v46");
             sql.execute(
                 "ALTER TABLE msgs ADD COLUMN mime_in_reply_to TEXT;",
                 params![],
@@ -785,7 +759,6 @@ fn open(
             sql.set_config_int(context, "dbversion", 54)?;
         }
         if dbversion < 55 {
-            info!(context, "[migration] v55");
             sql.execute(
                 "ALTER TABLE locations ADD COLUMN independent INTEGER DEFAULT 0;",
                 params![],
@@ -795,7 +768,6 @@ fn open(
         }
 
         if 0 != recalc_fingerprints {
-            info!(context, "[migration] recalc fingerprints");
             sql.query_map(
                 "SELECT addr FROM acpeerstates;",
                 params![],
@@ -805,7 +777,7 @@ fn open(
                         if let Some(ref mut peerstate) = Peerstate::from_addr(context, sql, &addr?)
                         {
                             peerstate.recalc_fingerprint();
-                            peerstate.save_to_db(sql, false)?;
+                            peerstate.save_to_db(sql, false).unwrap();
                         }
                     }
                     Ok(())
@@ -816,7 +788,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, "[migration] update file paths");
+
+            info!(context, "[open] update file paths");
+
             let repl_from = sql
                 .get_config(context, "backup_for")
                 .unwrap_or_else(|| context.get_blobdir().to_string_lossy().into());
@@ -1159,8 +1133,12 @@ mod test {
         maybe_add_file(&mut files, "$BLOBDIR/world.txt");
         maybe_add_file(&mut files, "world2.txt");
 
-        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"));
+        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"
+        ));
     }
 }

src/stock.rs

@@ -109,8 +109,6 @@ pub enum StockMessage {
     MsgLocationDisabled = 65,
     #[strum(props(fallback = "Location"))]
     Location = 66,
-    #[strum(props(fallback = "Sticker"))]
-    Sticker = 67,
 }
 
 impl StockMessage {
@@ -351,7 +349,9 @@ mod tests {
         let contact_id = {
             Contact::create(&t.ctx, "Alice", "alice@example.com")
                 .expect("Failed to create contact Alice");
-            Contact::create(&t.ctx, "Bob", "bob@example.com").expect("failed to create bob")
+            let id =
+                Contact::create(&t.ctx, "Bob", "bob@example.com").expect("failed to create bob");
+            id
         };
         assert_eq!(
             t.ctx.stock_system_msg(

src/top_evil_rs.py

@@ -21,8 +21,6 @@ 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,14 +1,9 @@
-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::*;
@@ -16,7 +11,6 @@ use mmime::mailmime::disposition::*;
 use mmime::mailmime::types::*;
 use mmime::mailmime::types_helper::*;
 use mmime::mailmime::*;
-use mmime::mmapstring::*;
 use mmime::other::*;
 
 #[macro_export]
@@ -49,23 +43,6 @@ pub fn get_ct_subtype(mime: *mut Mailmime) -> Option<String> {
     }
 }
 
-pub fn parse_message_id(message_id: &str) -> Result<String, Error> {
-    let mut dummy = 0;
-    let c_message_id = CString::new(message_id).unwrap();
-    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> {
@@ -111,192 +88,6 @@ 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 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()
-}
-
-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;
@@ -317,77 +108,48 @@ 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<Vec<u8>, Error> {
+) -> Result<(*mut libc::c_char, libc::size_t), 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
     {
-        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());
+        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;
         }
     }
-    // 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
+    Ok((decoded_data, decoded_data_bytes))
 }
 
 /**************************************
@@ -499,24 +261,6 @@ 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::*;
@@ -536,16 +280,4 @@ 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"
-        );
-    }
 }