refactor(imex): almost all unsafe gone here

deltachat-ffi/deltachat.h

@@ -3485,7 +3485,7 @@ int             dc_contact_is_verified       (dc_contact_t* contact);
  *     accessor functions.  If no provider info is found, NULL will be
  *     returned.
  */
-dc_provider_t*  dc_provider_new_from_domain           (const char* domain);
+dc_provider_t*  dc_provider_new_from_domain           (char* domain);
 
 
 /**
@@ -3499,7 +3499,7 @@ dc_provider_t*  dc_provider_new_from_domain           (const char* domain);
  *     accessor functions.  If no provider info is found, NULL will be
  *     returned.
  */
-dc_provider_t*  dc_provider_new_from_email            (const char* email);
+dc_provider_t*  dc_provider_new_from_email            (char* email);
 
 
 /**

deltachat-ffi/src/lib.rs

@@ -225,8 +225,8 @@ pub unsafe extern "C" fn dc_get_userdata(context: *mut dc_context_t) -> *mut lib
 #[no_mangle]
 pub unsafe extern "C" fn dc_open(
     context: *mut dc_context_t,
-    dbfile: *const libc::c_char,
-    blobdir: *const libc::c_char,
+    dbfile: *mut libc::c_char,
+    blobdir: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || dbfile.is_null() {
         eprintln!("ignoring careless call to dc_open()");
@@ -298,8 +298,8 @@ pub unsafe extern "C" fn dc_get_blobdir(context: *mut dc_context_t) -> *mut libc
 #[no_mangle]
 pub unsafe extern "C" fn dc_set_config(
     context: *mut dc_context_t,
-    key: *const libc::c_char,
-    value: *const libc::c_char,
+    key: *mut libc::c_char,
+    value: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || key.is_null() {
         eprintln!("ignoring careless call to dc_set_config()");
@@ -322,7 +322,7 @@ pub unsafe extern "C" fn dc_set_config(
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_config(
     context: *mut dc_context_t,
-    key: *const libc::c_char,
+    key: *mut libc::c_char,
 ) -> *mut libc::c_char {
     if context.is_null() || key.is_null() {
         eprintln!("ignoring careless call to dc_get_config()");
@@ -369,8 +369,8 @@ fn render_info(
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_oauth2_url(
     context: *mut dc_context_t,
-    addr: *const libc::c_char,
-    redirect: *const libc::c_char,
+    addr: *mut libc::c_char,
+    redirect: *mut libc::c_char,
 ) -> *mut libc::c_char {
     if context.is_null() {
         eprintln!("ignoring careless call to dc_get_oauth2_url()");
@@ -612,7 +612,7 @@ pub unsafe extern "C" fn dc_maybe_network(context: *mut dc_context_t) {
 pub unsafe extern "C" fn dc_get_chatlist(
     context: *mut dc_context_t,
     flags: libc::c_int,
-    query_str: *const libc::c_char,
+    query_str: *mut libc::c_char,
     query_id: u32,
 ) -> *mut dc_chatlist_t {
     if context.is_null() {
@@ -733,7 +733,7 @@ pub unsafe extern "C" fn dc_send_msg(
 pub unsafe extern "C" fn dc_send_text_msg(
     context: *mut dc_context_t,
     chat_id: u32,
-    text_to_send: *const libc::c_char,
+    text_to_send: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || text_to_send.is_null() {
         eprintln!("ignoring careless call to dc_send_text_msg()");
@@ -1017,7 +1017,7 @@ pub unsafe extern "C" fn dc_get_chat_contacts(
 pub unsafe extern "C" fn dc_search_msgs(
     context: *mut dc_context_t,
     chat_id: u32,
-    query: *const libc::c_char,
+    query: *mut libc::c_char,
 ) -> *mut dc_array::dc_array_t {
     if context.is_null() || query.is_null() {
         eprintln!("ignoring careless call to dc_search_msgs()");
@@ -1054,7 +1054,7 @@ pub unsafe extern "C" fn dc_get_chat(context: *mut dc_context_t, chat_id: u32) -
 pub unsafe extern "C" fn dc_create_group_chat(
     context: *mut dc_context_t,
     verified: libc::c_int,
-    name: *const libc::c_char,
+    name: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || name.is_null() {
         eprintln!("ignoring careless call to dc_create_group_chat()");
@@ -1131,7 +1131,7 @@ pub unsafe extern "C" fn dc_remove_contact_from_chat(
 pub unsafe extern "C" fn dc_set_chat_name(
     context: *mut dc_context_t,
     chat_id: u32,
-    name: *const libc::c_char,
+    name: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || chat_id <= constants::DC_CHAT_ID_LAST_SPECIAL as u32 || name.is_null() {
         eprintln!("ignoring careless call to dc_set_chat_name()");
@@ -1151,7 +1151,7 @@ pub unsafe extern "C" fn dc_set_chat_name(
 pub unsafe extern "C" fn dc_set_chat_profile_image(
     context: *mut dc_context_t,
     chat_id: u32,
-    image: *const libc::c_char,
+    image: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || chat_id <= constants::DC_CHAT_ID_LAST_SPECIAL as u32 {
         eprintln!("ignoring careless call to dc_set_chat_profile_image()");
@@ -1322,7 +1322,7 @@ pub unsafe extern "C" fn dc_get_msg(context: *mut dc_context_t, msg_id: u32) ->
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn dc_may_be_valid_addr(addr: *const libc::c_char) -> libc::c_int {
+pub unsafe extern "C" fn dc_may_be_valid_addr(addr: *mut libc::c_char) -> libc::c_int {
     if addr.is_null() {
         eprintln!("ignoring careless call to dc_may_be_valid_addr()");
         return 0;
@@ -1334,7 +1334,7 @@ pub unsafe extern "C" fn dc_may_be_valid_addr(addr: *const libc::c_char) -> libc
 #[no_mangle]
 pub unsafe extern "C" fn dc_lookup_contact_id_by_addr(
     context: *mut dc_context_t,
-    addr: *const libc::c_char,
+    addr: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || addr.is_null() {
         eprintln!("ignoring careless call to dc_lookup_contact_id_by_addr()");
@@ -1349,8 +1349,8 @@ pub unsafe extern "C" fn dc_lookup_contact_id_by_addr(
 #[no_mangle]
 pub unsafe extern "C" fn dc_create_contact(
     context: *mut dc_context_t,
-    name: *const libc::c_char,
-    addr: *const libc::c_char,
+    name: *mut libc::c_char,
+    addr: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || addr.is_null() {
         eprintln!("ignoring careless call to dc_create_contact()");
@@ -1369,7 +1369,7 @@ pub unsafe extern "C" fn dc_create_contact(
 #[no_mangle]
 pub unsafe extern "C" fn dc_add_address_book(
     context: *mut dc_context_t,
-    addr_book: *const libc::c_char,
+    addr_book: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || addr_book.is_null() {
         eprintln!("ignoring careless call to dc_add_address_book()");
@@ -1390,7 +1390,7 @@ pub unsafe extern "C" fn dc_add_address_book(
 pub unsafe extern "C" fn dc_get_contacts(
     context: *mut dc_context_t,
     flags: u32,
-    query: *const libc::c_char,
+    query: *mut libc::c_char,
 ) -> *mut dc_array::dc_array_t {
     if context.is_null() {
         eprintln!("ignoring careless call to dc_get_contacts()");
@@ -1521,8 +1521,8 @@ pub unsafe extern "C" fn dc_get_contact(
 pub unsafe extern "C" fn dc_imex(
     context: *mut dc_context_t,
     what: libc::c_int,
-    param1: *const libc::c_char,
-    _param2: *const libc::c_char,
+    param1: *mut libc::c_char,
+    _param2: *mut libc::c_char,
 ) {
     if context.is_null() {
         eprintln!("ignoring careless call to dc_imex()");
@@ -1545,7 +1545,7 @@ pub unsafe extern "C" fn dc_imex(
 #[no_mangle]
 pub unsafe extern "C" fn dc_imex_has_backup(
     context: *mut dc_context_t,
-    dir: *const libc::c_char,
+    dir: *mut libc::c_char,
 ) -> *mut libc::c_char {
     if context.is_null() || dir.is_null() {
         eprintln!("ignoring careless call to dc_imex_has_backup()");
@@ -1585,7 +1585,7 @@ pub unsafe extern "C" fn dc_initiate_key_transfer(context: *mut dc_context_t) ->
 pub unsafe extern "C" fn dc_continue_key_transfer(
     context: *mut dc_context_t,
     msg_id: u32,
-    setup_code: *const libc::c_char,
+    setup_code: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null()
         || msg_id <= constants::DC_MSG_ID_LAST_SPECIAL as u32
@@ -1623,7 +1623,7 @@ pub unsafe extern "C" fn dc_stop_ongoing_process(context: *mut dc_context_t) {
 #[no_mangle]
 pub unsafe extern "C" fn dc_check_qr(
     context: *mut dc_context_t,
-    qr: *const libc::c_char,
+    qr: *mut libc::c_char,
 ) -> *mut dc_lot_t {
     if context.is_null() || qr.is_null() {
         eprintln!("ignoring careless call to dc_check_qr()");
@@ -1660,7 +1660,7 @@ pub unsafe extern "C" fn dc_get_securejoin_qr(
 #[no_mangle]
 pub unsafe extern "C" fn dc_join_securejoin(
     context: *mut dc_context_t,
-    qr: *const libc::c_char,
+    qr: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || qr.is_null() {
         eprintln!("ignoring careless call to dc_join_securejoin()");
@@ -2577,7 +2577,7 @@ pub unsafe extern "C" fn dc_msg_get_setupcodebegin(msg: *mut dc_msg_t) -> *mut l
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn dc_msg_set_text(msg: *mut dc_msg_t, text: *const libc::c_char) {
+pub unsafe extern "C" fn dc_msg_set_text(msg: *mut dc_msg_t, text: *mut libc::c_char) {
     if msg.is_null() {
         eprintln!("ignoring careless call to dc_msg_set_text()");
         return;
@@ -2590,8 +2590,8 @@ pub unsafe extern "C" fn dc_msg_set_text(msg: *mut dc_msg_t, text: *const libc::
 #[no_mangle]
 pub unsafe extern "C" fn dc_msg_set_file(
     msg: *mut dc_msg_t,
-    file: *const libc::c_char,
-    filemime: *const libc::c_char,
+    file: *mut libc::c_char,
+    filemime: *mut libc::c_char,
 ) {
     if msg.is_null() || file.is_null() {
         eprintln!("ignoring careless call to dc_msg_set_file()");

mmime/src/mailimf/types.rs

@@ -888,7 +888,6 @@ pub unsafe fn mailimf_fields_new(mut fld_list: *mut clist) -> *mut mailimf_field
     (*fields).fld_list = fld_list;
     return fields;
 }
-
 #[no_mangle]
 pub unsafe fn mailimf_field_new(
     mut fld_type: libc::c_int,
@@ -948,20 +947,6 @@ pub unsafe fn mailimf_field_new(
     }
     return field;
 }
-
-#[no_mangle]
-pub unsafe fn mailimf_field_new_subject(fld_subject: *mut mailimf_subject) -> *mut mailimf_field {
-    let mut field: *mut mailimf_field = 0 as *mut mailimf_field;
-    field = malloc(::std::mem::size_of::<mailimf_field>() as libc::size_t) as *mut mailimf_field;
-    if field.is_null() {
-        return 0 as *mut mailimf_field;
-    }
-    (*field).fld_type = MAILIMF_FIELD_SUBJECT as libc::c_int;
-    (*field).fld_data.fld_subject = fld_subject;
-
-    field
-}
-
 #[no_mangle]
 pub unsafe fn mailimf_orig_date_new(
     mut dt_date_time: *mut mailimf_date_time,

mmime/src/mailmime/types.rs

@@ -708,28 +708,6 @@ pub unsafe fn mailmime_new(
     return mime;
 }
 
-pub unsafe fn mailmime_new_simple(
-    mut mm_type: libc::c_int,
-    mut mm_mime_fields: *mut mailmime_fields,
-    mut mm_content_type: *mut mailmime_content,
-    mut mm_fields: *mut mailimf_fields,
-    mut mm_msg_mime: *mut Mailmime,
-) -> *mut Mailmime {
-    mailmime_new(
-        mm_type,
-        std::ptr::null(),
-        0,
-        mm_mime_fields,
-        mm_content_type,
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-        mm_fields,
-        mm_msg_mime,
-    )
-}
-
 pub unsafe fn mailmime_free(mut mime: *mut Mailmime) {
     match (*mime).mm_type {
         1 => {

src/contact.rs

@@ -804,14 +804,14 @@ impl Contact {
         }
 
         if let Some(peerstate) = peerstate {
-            if peerstate.verified_key.is_some() {
+            if peerstate.verified_key().is_some() {
                 return VerifiedStatus::BidirectVerified;
             }
         }
 
         let peerstate = Peerstate::from_addr(context, &context.sql, &self.addr);
         if let Some(ps) = peerstate {
-            if ps.verified_key.is_some() {
+            if ps.verified_key().is_some() {
                 return VerifiedStatus::BidirectVerified;
             }
         }

src/context.rs

@@ -1,7 +1,5 @@
 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};
 
@@ -10,7 +8,6 @@ use libc::uintptr_t;
 use crate::chat::*;
 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::*;
@@ -23,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]
 ///
@@ -162,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)
     }
@@ -493,7 +438,6 @@ pub fn get_version_str() -> &'static str {
 mod tests {
     use super::*;
 
-    use crate::dc_tools::*;
     use crate::test_utils::*;
 
     #[test]
@@ -531,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

@@ -5,6 +5,7 @@ use std::ptr;
 use charset::Charset;
 use deltachat_derive::{FromSql, ToSql};
 use libc::{strcmp, strlen, strncmp};
+use mmime::clist::*;
 use mmime::mailimf::types::*;
 use mmime::mailimf::*;
 use mmime::mailmime::content::*;
@@ -20,7 +21,7 @@ use crate::context::Context;
 use crate::dc_simplify::*;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
-use crate::e2ee;
+use crate::e2ee::*;
 use crate::error::Error;
 use crate::location;
 use crate::param::*;
@@ -37,9 +38,7 @@ pub struct MimeParser<'a> {
     pub subject: Option<String>,
     pub is_send_by_messenger: bool,
     pub decrypting_failed: bool,
-    pub encrypted: bool,
-    pub signatures: HashSet<String>,
-    pub gossipped_addr: HashSet<String>,
+    pub e2ee_helper: E2eeHelper,
     pub is_forwarded: bool,
     pub reports: Vec<*mut Mailmime>,
     pub is_system_message: SystemMessage,
@@ -93,9 +92,7 @@ impl<'a> MimeParser<'a> {
             subject: None,
             is_send_by_messenger: false,
             decrypting_failed: false,
-            encrypted: false,
-            signatures: Default::default(),
-            gossipped_addr: Default::default(),
+            e2ee_helper: Default::default(),
             is_forwarded: false,
             context,
             reports: Vec::new(),
@@ -116,11 +113,7 @@ impl<'a> MimeParser<'a> {
         );
 
         if r == MAILIMF_NO_ERROR as libc::c_int && !self.mimeroot.is_null() {
-            let (encrypted, signatures, gossipped_addr) =
-                e2ee::try_decrypt(self.context, self.mimeroot)?;
-            self.encrypted = encrypted;
-            self.signatures = signatures;
-            self.gossipped_addr = gossipped_addr;
+            self.e2ee_helper.try_decrypt(self.context, self.mimeroot)?;
             self.parse_mime_recursive(self.mimeroot);
 
             if let Some(field) = self.lookup_field("Subject") {
@@ -776,40 +769,34 @@ 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) {
-        if self.encrypted && self.signatures.len() > 0 {
+        if self.e2ee_helper.encrypted && self.e2ee_helper.signatures.len() > 0 {
             part.param.set_int(Param::GuranteeE2ee, 1);
-        } else if self.encrypted {
+        } else if self.e2ee_helper.encrypted {
             part.param.set_int(Param::ErroneousE2ee, 0x2);
         }
         self.parts.push(part);
@@ -1217,61 +1204,50 @@ pub unsafe fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, E
     Err(format_err!("Failed to to decode"))
 }
 
-pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String> {
+pub unsafe 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() } {
+    for cur in (*(*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 {
+        match (*fld).fld_type {
             13 => {
-                fld_to = unsafe { fld.fld_data.fld_to };
+                fld_to = (*fld).fld_data.fld_to;
                 if !fld_to.is_null() {
-                    addr_list = unsafe { (*fld_to).to_addr_list };
+                    addr_list = (*fld_to).to_addr_list
                 }
             }
             14 => {
-                fld_cc = unsafe { fld.fld_data.fld_cc };
+                fld_cc = (*fld).fld_data.fld_cc;
                 if !fld_cc.is_null() {
-                    addr_list = unsafe { (*fld_cc).cc_addr_list };
+                    addr_list = (*fld_cc).cc_addr_list
                 }
             }
             _ => {}
         }
 
         if !addr_list.is_null() {
-            for cur2 in unsafe { &(*(*addr_list).ad_list) } {
+            for cur2 in (*(*addr_list).ad_list).into_iter() {
                 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,
-                            );
+                if !adr.is_null() {
+                    if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
+                        mailimf_get_recipients_add_addr(&mut recipients, (*adr).ad_data.ad_mailbox);
+                    } else if (*adr).ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
+                        let group: *mut mailimf_group = (*adr).ad_data.ad_group;
+                        if !group.is_null() && !(*group).grp_mb_list.is_null() {
+                            for cur3 in (*(*(*group).grp_mb_list).mb_list).into_iter() {
+                                mailimf_get_recipients_add_addr(
+                                    &mut recipients,
+                                    cur3 as *mut mailimf_mailbox,
+                                );
+                            }
                         }
                     }
                 }
@@ -1290,26 +1266,30 @@ fn mailimf_get_recipients_add_addr(recipients: &mut HashSet<String>, mb: *mut ma
 }
 
 /*the result is a pointer to mime, must not be freed*/
-pub fn mailimf_find_field(
+pub unsafe fn mailimf_find_field(
     header: *mut mailimf_fields,
     wanted_fld_type: libc::c_int,
 ) -> *mut mailimf_field {
-    if header.is_null() {
+    if header.is_null() || (*header).fld_list.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;
+    let mut cur1: *mut clistiter = (*(*header).fld_list).first;
+    while !cur1.is_null() {
+        let field: *mut mailimf_field = (if !cur1.is_null() {
+            (*cur1).data
+        } else {
+            ptr::null_mut()
+        }) as *mut mailimf_field;
         if !field.is_null() {
-            if unsafe { (*field).fld_type } == wanted_fld_type {
+            if (*field).fld_type == wanted_fld_type {
                 return field;
             }
         }
+        cur1 = if !cur1.is_null() {
+            (*cur1).next
+        } else {
+            ptr::null_mut()
+        }
     }
 
     ptr::null_mut()

src/dc_receive_imf.rs

@@ -610,7 +610,7 @@ unsafe fn add_parts(
     let icnt = mime_parser.parts.len();
     let mut txt_raw = None;
 
-    context
+    let is_ok = context
         .sql
         .prepare(
             "INSERT INTO msgs \
@@ -697,10 +697,13 @@ unsafe fn add_parts(
                 Ok(())
             },
         )
-        .map_err(|err| {
-            cleanup(mime_in_reply_to, mime_references);
-            err
-        })?;
+        .is_ok();
+
+    if !is_ok {
+        // i/o error - there is nothing more we can do - in other cases, we try to write at least an empty record
+        cleanup(mime_in_reply_to, mime_references);
+        bail!("Cannot write DB.");
+    }
 
     info!(
         context,
@@ -1606,7 +1609,10 @@ fn check_verified_properties(
 ) -> Result<()> {
     let contact = Contact::load_from_db(context, from_id)?;
 
-    ensure!(mimeparser.encrypted, "This message is not encrypted.");
+    ensure!(
+        mimeparser.e2ee_helper.encrypted,
+        "This message is not encrypted."
+    );
 
     // ensure, the contact is verified
     // and the message is signed with a verified key of the sender.
@@ -1627,7 +1633,7 @@ fn check_verified_properties(
 
         if let Some(peerstate) = peerstate {
             ensure!(
-                peerstate.has_verified_key(&mimeparser.signatures),
+                peerstate.has_verified_key(&mimeparser.e2ee_helper.signatures),
                 "The message was sent with non-verified encryption."
             );
         }
@@ -1654,7 +1660,7 @@ fn check_verified_properties(
         let mut peerstate = Peerstate::from_addr(context, &context.sql, &to_addr);
 
         // mark gossiped keys (if any) as verified
-        if mimeparser.gossipped_addr.contains(&to_addr) && peerstate.is_some() {
+        if mimeparser.e2ee_helper.gossipped_addr.contains(&to_addr) && peerstate.is_some() {
             let peerstate = peerstate.as_mut().unwrap();
 
             // if we're here, we know the gossip key is verified:

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;
@@ -218,26 +217,26 @@ pub(crate) fn dc_str_to_color(s: impl AsRef<str>) -> u32 {
 
 /* date/time tools */
 /* the result is UTC or DC_INVALID_TIMESTAMP */
-pub(crate) fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> i64 {
-    assert!(!date_time.is_null());
-    let dt = unsafe { *date_time };
-
-    let sec = dt.dt_sec;
-    let min = dt.dt_min;
-    let hour = dt.dt_hour;
-    let day = dt.dt_day;
-    let month = dt.dt_month;
-    let year = dt.dt_year;
+pub(crate) unsafe fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> i64 {
+    let sec = (*date_time).dt_sec;
+    let min = (*date_time).dt_min;
+    let hour = (*date_time).dt_hour;
+    let day = (*date_time).dt_day;
+    let month = (*date_time).dt_month;
+    let year = (*date_time).dt_year;
 
     let ts = chrono::NaiveDateTime::new(
         chrono::NaiveDate::from_ymd(year, month as u32, day as u32),
         chrono::NaiveTime::from_hms(hour as u32, min as u32, sec as u32),
     );
 
-    let (zone_hour, zone_min) = if dt.dt_zone >= 0 {
-        (dt.dt_zone / 100, dt.dt_zone % 100)
+    let (zone_hour, zone_min) = if (*date_time).dt_zone >= 0 {
+        ((*date_time).dt_zone / 100, (*date_time).dt_zone % 100)
     } else {
-        (-(-dt.dt_zone / 100), -(-dt.dt_zone % 100))
+        (
+            -(-(*date_time).dt_zone / 100),
+            -(-(*date_time).dt_zone % 100),
+        )
     };
 
     ts.timestamp() - (zone_hour * 3600 + zone_min * 60) as i64
@@ -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

@@ -1,10 +1,11 @@
 //! End-to-end encryption support.
 
 use std::collections::HashSet;
+use std::ffi::CStr;
 use std::ptr;
 use std::str::FromStr;
 
-use libc::strlen;
+use libc::{strcmp, strlen, strncmp};
 use mmime::clist::*;
 use mmime::mailimf::types::*;
 use mmime::mailimf::types_helper::*;
@@ -17,7 +18,6 @@ use mmime::mailmime::*;
 use mmime::mailprivacy_prepare_mime;
 use mmime::mmapstring::*;
 use mmime::{mailmime_substitute, MAILIMF_NO_ERROR, MAIL_NO_ERROR};
-use num_traits::FromPrimitive;
 
 use crate::aheader::*;
 use crate::config::Config;
@@ -47,12 +47,12 @@ pub struct EncryptHelper {
 
 impl EncryptHelper {
     pub fn new(context: &Context) -> Result<EncryptHelper> {
-        let prefer_encrypt = context
-            .sql
-            .get_config_int(&context, "e2ee_enabled")
-            .and_then(EncryptPreference::from_i32)
-            .unwrap_or_default();
-
+        let e2ee = context.sql.get_config_int(&context, "e2ee_enabled");
+        let prefer_encrypt = if 0 != e2ee.unwrap_or_default() {
+            EncryptPreference::Mutual
+        } else {
+            EncryptPreference::NoPreference
+        };
         let addr = match context.get_config(Config::ConfiguredAddr) {
             None => {
                 bail!("addr not configured!");
@@ -61,7 +61,6 @@ impl EncryptHelper {
         };
 
         let public_key = load_or_generate_self_public_key(context, &addr)?;
-
         Ok(EncryptHelper {
             prefer_encrypt,
             addr,
@@ -84,13 +83,11 @@ impl EncryptHelper {
         mut in_out_message: *mut Mailmime,
         imffields_unprotected: *mut mailimf_fields,
     ) -> Result<bool> {
-        // libEtPan's pgp_encrypt_mime() takes the parent as the new root.
-        // We just expect the root as being given to this function.
-        ensure!(
-            !in_out_message.is_null() && unsafe { (*in_out_message).mm_parent.is_null() },
-            "corrupted inputs"
-        );
-
+        /* libEtPan's pgp_encrypt_mime() takes the parent as the new root.
+        We just expect the root as being given to this function. */
+        if in_out_message.is_null() || unsafe { !(*in_out_message).mm_parent.is_null() } {
+            bail!("corrupted inputs");
+        }
         if !(self.prefer_encrypt == EncryptPreference::Mutual || e2ee_guaranteed) {
             return Ok(false);
         }
@@ -109,14 +106,13 @@ impl EncryptHelper {
                 None => {
                     let msg = format!("peerstate for {} missing, cannot encrypt", recipient_addr);
                     if e2ee_guaranteed {
-                        return Err(format_err!("{}", msg));
+                        bail!("{}", msg);
                     } else {
                         info!(context, "{}", msg);
                         return Ok(false);
                     }
                 }
             };
-
             if peerstate.prefer_encrypt != EncryptPreference::Mutual && !e2ee_guaranteed {
                 info!(context, "peerstate for {} is no-encrypt", recipient_addr);
                 return Ok(false);
@@ -140,24 +136,30 @@ impl EncryptHelper {
         let sign_key = {
             keyring.add_ref(&self.public_key);
             let key = Key::from_self_private(context, self.addr.clone(), &context.sql);
-            ensure!(key.is_some(), "no own private key found");
-
+            if key.is_none() {
+                bail!("no own private key found")
+            }
             key
         };
 
-        // encrypt message
+        /* encrypt message */
         unsafe {
             mailprivacy_prepare_mime(in_out_message);
-            let mut part_to_encrypt = (*in_out_message).mm_data.mm_message.mm_msg_mime;
+            let mut part_to_encrypt: *mut Mailmime =
+                (*in_out_message).mm_data.mm_message.mm_msg_mime;
             (*part_to_encrypt).mm_parent = ptr::null_mut();
-            let imffields_encrypted = mailimf_fields_new_empty();
-
-            // mailmime_new_message_data() calls mailmime_fields_new_with_version()
-            // which would add the unwanted MIME-Version:-header
-            let message_to_encrypt = mailmime_new_simple(
+            let imffields_encrypted: *mut mailimf_fields = mailimf_fields_new_empty();
+            /* mailmime_new_message_data() calls mailmime_fields_new_with_version() which would add the unwanted MIME-Version:-header */
+            let message_to_encrypt: *mut Mailmime = mailmime_new(
                 MAILMIME_MESSAGE as libc::c_int,
+                ptr::null(),
+                0 as libc::size_t,
                 mailmime_fields_new_empty(),
                 mailmime_get_content_message(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
                 imffields_encrypted,
                 part_to_encrypt,
             );
@@ -166,13 +168,12 @@ impl EncryptHelper {
                 wrapmime::new_custom_field(imffields_encrypted, "Autocrypt-Gossip", &header)
             }
 
-            // memoryhole headers: move some headers into encrypted part
+            /* memoryhole headers: move some headers into encrypted part */
             // XXX note we can't use clist's into_iter() because the loop body also removes items
-            let mut cur = (*(*imffields_unprotected).fld_list).first;
+            let mut cur: *mut clistiter = (*(*imffields_unprotected).fld_list).first;
             while !cur.is_null() {
-                let field = (*cur).data as *mut mailimf_field;
+                let field: *mut mailimf_field = (*cur).data as *mut mailimf_field;
                 let mut move_to_encrypted = false;
-
                 if !field.is_null() {
                     if (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
                         move_to_encrypted = true;
@@ -188,7 +189,6 @@ impl EncryptHelper {
                         }
                     }
                 }
-
                 if move_to_encrypted {
                     mailimf_fields_add(imffields_encrypted, field);
                     cur = clist_delete((*imffields_unprotected).fld_list, cur);
@@ -196,24 +196,48 @@ impl EncryptHelper {
                     cur = (*cur).next;
                 }
             }
-
-            let subject = mailimf_subject_new("...".strdup());
-            mailimf_fields_add(imffields_unprotected, mailimf_field_new_subject(subject));
-
+            let subject: *mut mailimf_subject = mailimf_subject_new("...".strdup());
+            mailimf_fields_add(
+                imffields_unprotected,
+                mailimf_field_new(
+                    MAILIMF_FIELD_SUBJECT as libc::c_int,
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    subject,
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                ),
+            );
             wrapmime::append_ct_param(
                 (*part_to_encrypt).mm_content_type,
                 "protected-headers",
                 "v1",
             )?;
-            let plain = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
-            let mut col = 0;
+            let plain: *mut MMAPString =
+                mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
+            let mut col: libc::c_int = 0i32;
             mailmime_write_mem(plain, &mut col, message_to_encrypt);
             mailmime_free(message_to_encrypt);
-
-            ensure!(
-                !(*plain).str_0.is_null() && (*plain).len > 0,
-                "could not write/allocate"
-            );
+            if (*plain).str_0.is_null() || (*plain).len <= 0 {
+                bail!("could not write/allocate");
+            }
 
             let ctext = dc_pgp_pk_encrypt(
                 std::slice::from_raw_parts((*plain).str_0 as *const u8, (*plain).len),
@@ -222,148 +246,165 @@ impl EncryptHelper {
             );
             mmap_string_free(plain);
 
-            let ctext_v = ctext?;
+            if let Ok(ctext_v) = ctext {
+                /* create MIME-structure that will contain the encrypted text */
+                let mut encrypted_part: *mut Mailmime = new_data_part(
+                    ptr::null_mut(),
+                    0 as libc::size_t,
+                    "multipart/encrypted",
+                    MAILMIME_MECHANISM_BASE64,
+                )?;
+                let content: *mut mailmime_content = (*encrypted_part).mm_content_type;
+                wrapmime::append_ct_param(content, "protocol", "application/pgp-encrypted")?;
+                let version_mime: *mut Mailmime = new_data_part(
+                    VERSION_CONTENT.as_mut_ptr() as *mut libc::c_void,
+                    strlen(VERSION_CONTENT.as_mut_ptr()),
+                    "application/pgp-encrypted",
+                    MAILMIME_MECHANISM_7BIT,
+                )?;
+                mailmime_smart_add_part(encrypted_part, version_mime);
 
-            // create MIME-structure that will contain the encrypted text
-            let mut encrypted_part = new_data_part(
-                ptr::null_mut(),
-                0 as libc::size_t,
-                "multipart/encrypted",
-                MAILMIME_MECHANISM_BASE64,
-            )?;
-            let content = (*encrypted_part).mm_content_type;
-            wrapmime::append_ct_param(content, "protocol", "application/pgp-encrypted")?;
-
-            let version_mime = new_data_part(
-                VERSION_CONTENT.as_mut_ptr() as *mut libc::c_void,
-                strlen(VERSION_CONTENT.as_mut_ptr()),
-                "application/pgp-encrypted",
-                MAILMIME_MECHANISM_7BIT,
-            )?;
-            mailmime_smart_add_part(encrypted_part, version_mime);
-
-            // we assume that ctext_v is not dropped until the end
-            // of this if-scope
-            let ctext_part = new_data_part(
-                ctext_v.as_ptr() as *mut libc::c_void,
-                ctext_v.len(),
-                "application/octet-stream",
-                MAILMIME_MECHANISM_7BIT,
-            )?;
-
-            mailmime_smart_add_part(encrypted_part, ctext_part);
-            (*in_out_message).mm_data.mm_message.mm_msg_mime = encrypted_part;
-            (*encrypted_part).mm_parent = in_out_message;
-            let gossiped = !&gossip_headers.is_empty();
-            factory.finalize_mime_message(in_out_message, true, gossiped)?;
-
-            Ok(true)
+                // we assume that ctext_v is not dropped until the end
+                // of this if-scope
+                let ctext_part: *mut Mailmime = new_data_part(
+                    ctext_v.as_ptr() as *mut libc::c_void,
+                    ctext_v.len(),
+                    "application/octet-stream",
+                    MAILMIME_MECHANISM_7BIT,
+                )?;
+                mailmime_smart_add_part(encrypted_part, ctext_part);
+                (*in_out_message).mm_data.mm_message.mm_msg_mime = encrypted_part;
+                (*encrypted_part).mm_parent = in_out_message;
+                let gossiped = !&gossip_headers.is_empty();
+                factory.finalize_mime_message(in_out_message, true, gossiped)?;
+                Ok(true)
+            } else {
+                bail!("encryption failed")
+            }
         }
     }
 }
 
-pub fn try_decrypt(
-    context: &Context,
-    in_out_message: *mut Mailmime,
-) -> Result<(bool, HashSet<String>, HashSet<String>)> {
-    let mut encrypted = false;
-    let mut signatures = HashSet::default();
-    let mut gossipped_addr = HashSet::default();
+#[derive(Debug, Default)]
+pub struct E2eeHelper {
+    // for decrypting only
+    pub encrypted: bool,
+    pub signatures: HashSet<String>,
+    pub gossipped_addr: HashSet<String>,
+}
 
-    // 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();
+impl E2eeHelper {
+    pub unsafe fn try_decrypt(
+        &mut self,
+        context: &Context,
+        in_out_message: *mut Mailmime,
+    ) -> Result<()> {
+        /*just a pointer into mailmime structure, must not be freed*/
+        let imffields: *mut mailimf_fields = mailmime_find_mailimf_fields(in_out_message);
+        let mut message_time = 0;
+        let mut from = None;
+        let mut private_keyring = Keyring::default();
+        let mut public_keyring_for_validate = Keyring::default();
+        let mut gossip_headers: *mut mailimf_fields = ptr::null_mut();
 
-    // 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);
+        // 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);
-        }
+            if !field.is_null() && !(*field).fld_data.fld_from.is_null() {
+                from = mailimf_find_first_addr((*(*field).fld_data.fld_from).frm_mb_list)
+            }
 
-        field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
-        if !field.is_null() && 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()
+            field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
+            if !field.is_null() && !(*field).fld_data.fld_orig_date.is_null() {
+                let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
+                if !orig_date.is_null() {
+                    message_time = dc_timestamp_from_date((*orig_date).dt_date_time);
+                    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 peerstate = None;
+            let autocryptheader = from
+                .as_ref()
+                .and_then(|from| Aheader::from_imffields(from, imffields));
+            if message_time > 0 {
+                if let Some(ref from) = from {
+                    peerstate = Peerstate::from_addr(context, &context.sql, from);
 
-                if let Some(ref mut peerstate) = peerstate {
-                    if let Some(ref header) = autocryptheader {
-                        peerstate.apply_header(&header, message_time);
-                        peerstate.save_to_db(&context.sql, false).unwrap();
-                    } else if message_time > peerstate.last_seen_autocrypt
-                        && !contains_report(in_out_message)
-                    {
-                        peerstate.degrade_encryption(message_time);
-                        peerstate.save_to_db(&context.sql, false).unwrap();
+                    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);
                     }
-                } 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(
+            /* 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,
-                    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)?;
+                    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);
+                        }
+                    }
+
+                    match decrypt_if_autocrypt_message(
+                        context,
+                        in_out_message,
+                        &private_keyring,
+                        &public_keyring_for_validate,
+                        &mut self.signatures,
+                        &mut gossip_headers,
+                    ) {
+                        Ok(res) => {
+                            self.encrypted = res;
+                        }
+                        Err(err) => {
+                            bail!("failed to decrypt: {}", err);
+                        }
+                    }
+                    if !gossip_headers.is_null() {
+                        self.gossipped_addr = update_gossip_peerstates(
+                            context,
+                            message_time,
+                            imffields,
+                            gossip_headers,
+                        )
+                    }
                 }
             }
         }
+        if !gossip_headers.is_null() {
+            mailimf_fields_free(gossip_headers);
+        }
+        Ok(())
     }
-    if !gossip_headers.is_null() {
-        unsafe { mailimf_fields_free(gossip_headers) };
-    }
-
-    Ok((encrypted, signatures, gossipped_addr))
 }
 
 fn new_data_part(
@@ -373,34 +414,31 @@ fn new_data_part(
     default_encoding: u32,
 ) -> Result<*mut Mailmime> {
     let content = new_content_type(&content_type)?;
-    let mut encoding = ptr::null_mut();
-    if wrapmime::content_type_needs_encoding(content) {
-        encoding = unsafe { mailmime_mechanism_new(default_encoding as i32, ptr::null_mut()) };
-        ensure!(!encoding.is_null(), "failed to create encoding");
-    }
-    let mime_fields = {
-        unsafe {
-            mailmime_fields_new_with_data(
-                encoding,
-                ptr::null_mut(),
-                ptr::null_mut(),
-                ptr::null_mut(),
-                ptr::null_mut(),
-            )
+    unsafe {
+        let mut encoding: *mut mailmime_mechanism = ptr::null_mut();
+        if wrapmime::content_type_needs_encoding(content) {
+            encoding = mailmime_mechanism_new(default_encoding as i32, ptr::null_mut());
+            ensure!(!encoding.is_null(), "failed to create encoding");
         }
-    };
-    ensure!(!mime_fields.is_null(), "internal mime error");
+        let mime_fields = mailmime_fields_new_with_data(
+            encoding,
+            ptr::null_mut(),
+            ptr::null_mut(),
+            ptr::null_mut(),
+            ptr::null_mut(),
+        );
+        ensure!(!mime_fields.is_null(), "internal mime error");
 
-    let mime = unsafe { mailmime_new_empty(content, mime_fields) };
-    ensure!(!mime.is_null(), "internal mime error");
+        let mime = mailmime_new_empty(content, mime_fields);
+        ensure!(!mime.is_null(), "internal mime error");
 
-    if unsafe { (*mime).mm_type } == MAILMIME_SINGLE as libc::c_int {
-        if !data.is_null() && data_bytes > 0 {
-            unsafe { mailmime_set_body_text(mime, data as *mut libc::c_char, data_bytes) };
+        if (*mime).mm_type == MAILMIME_SINGLE as libc::c_int {
+            if !data.is_null() && data_bytes > 0 {
+                mailmime_set_body_text(mime, data as *mut libc::c_char, data_bytes);
+            }
         }
+        return Ok(mime);
     }
-
-    Ok(mime)
 }
 
 /// Load public key from database or generate a new one.
@@ -450,37 +488,31 @@ fn load_or_generate_self_public_key(context: &Context, self_addr: impl AsRef<str
     }
 }
 
-fn update_gossip_peerstates(
+unsafe fn update_gossip_peerstates(
     context: &Context,
     message_time: i64,
     imffields: *mut mailimf_fields,
     gossip_headers: *const mailimf_fields,
-) -> Result<HashSet<String>> {
+) -> HashSet<String> {
     // XXX split the parsing from the modification part
     let mut recipients: Option<HashSet<String>> = None;
     let mut gossipped_addr: HashSet<String> = Default::default();
 
-    for cur_data in unsafe { (*(*gossip_headers).fld_list).into_iter() } {
-        let field = cur_data as *mut mailimf_field;
-        if field.is_null() {
-            continue;
-        }
-
-        let field = unsafe { *field };
-
-        if field.fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let optional_field = unsafe { field.fld_data.fld_optional_field };
-            if optional_field.is_null() {
-                continue;
-            }
-
-            let optional_field = unsafe { *optional_field };
-            if !optional_field.fld_name.is_null()
-                && as_str(optional_field.fld_name) == "Autocrypt-Gossip"
+    for cur_data in (*(*gossip_headers).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 = (*field).fld_data.fld_optional_field;
+            if !optional_field.is_null()
+                && !(*optional_field).fld_name.is_null()
+                && strcasecmp(
+                    (*optional_field).fld_name,
+                    b"Autocrypt-Gossip\x00" as *const u8 as *const libc::c_char,
+                ) == 0i32
             {
-                let value = to_string_lossy(optional_field.fld_value);
-                let gossip_header = Aheader::from_str(&value);
-
+                let value = CStr::from_ptr((*optional_field).fld_value)
+                    .to_str()
+                    .unwrap();
+                let gossip_header = Aheader::from_str(value);
                 if let Ok(ref header) = gossip_header {
                     if recipients.is_none() {
                         recipients = Some(mailimf_get_recipients(imffields));
@@ -490,15 +522,15 @@ fn update_gossip_peerstates(
                             Peerstate::from_addr(context, &context.sql, &header.addr);
                         if let Some(ref mut peerstate) = peerstate {
                             peerstate.apply_gossip(header, message_time);
-                            peerstate.save_to_db(&context.sql, false)?;
+                            peerstate.save_to_db(&context.sql, false).unwrap();
                         } else {
                             let p = Peerstate::from_gossip(context, header, message_time);
-                            p.save_to_db(&context.sql, true)?;
+                            p.save_to_db(&context.sql, true).unwrap();
                             peerstate = Some(p);
                         }
                         if let Some(peerstate) = peerstate {
                             if peerstate.degrade_event.is_some() {
-                                handle_degrade_event(context, &peerstate)?;
+                                handle_degrade_event(context, &peerstate);
                             }
                         }
 
@@ -515,7 +547,7 @@ fn update_gossip_peerstates(
         }
     }
 
-    Ok(gossipped_addr)
+    gossipped_addr
 }
 
 fn decrypt_if_autocrypt_message(
@@ -550,15 +582,16 @@ fn decrypt_if_autocrypt_message(
         public_keyring_for_validate,
         ret_valid_signatures,
     )?;
-    // decrypted_mime is a dangling pointer which we now put into mailmime's Ownership
+    /* decrypted_mime is a dangling pointer which we now put into
+    mailmime's Ownership */
     unsafe {
         mailmime_substitute(mime, decrypted_mime);
         mailmime_free(mime);
     }
 
-    // finally, let's also return gossip headers
-    // XXX better return parsed headers so that upstream
-    // does not need to dive into mmime-stuff again.
+    /* finally, let's also return gossip headers
+    XXX better return parsed headers so that upstream
+    does not need to dive into mmime-stuff again. */
     unsafe {
         if (*ret_gossip_headers).is_null() && ret_valid_signatures.len() > 0 {
             let mut dummy: libc::size_t = 0;
@@ -571,12 +604,11 @@ fn decrypt_if_autocrypt_message(
             ) == MAILIMF_NO_ERROR as libc::c_int
                 && !test.is_null()
             {
-                *ret_gossip_headers = test;
+                *ret_gossip_headers = test
             }
         }
     }
-
-    Ok(true)
+    return Ok(true);
 }
 
 fn decrypt_part(
@@ -602,75 +634,74 @@ fn decrypt_part(
 
     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.
+    /* encrypted, non-NULL decoded data in decoded_data now ...
+    Note that we need to take care of freeing decoded_data ourself,
+    after encryption has been attempted.
+    */
     let mut ret_decrypted_mime = ptr::null_mut();
 
-    ensure!(!decoded_data.is_null(), "Missing data");
-    let data = unsafe { std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes) };
-    if has_decrypted_pgp_armor(data) {
-        // we should only have one decryption happening
-        ensure!(ret_valid_signatures.is_empty(), "corrupt signatures");
+    unsafe {
+        if has_decrypted_pgp_armor(decoded_data, decoded_data_bytes as libc::c_int) {
+            /* we should only have one decryption happening */
+            ensure!(ret_valid_signatures.is_empty(), "corrupt signatures");
 
-        let plain = match dc_pgp_pk_decrypt(
-            data,
-            &private_keyring,
-            &public_keyring_for_validate,
-            Some(ret_valid_signatures),
-        ) {
-            Ok(plain) => {
-                ensure!(!ret_valid_signatures.is_empty(), "no valid signatures");
-                plain
-            }
-            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;
+            let plain = match dc_pgp_pk_decrypt(
+                std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes),
+                &private_keyring,
+                &public_keyring_for_validate,
+                Some(ret_valid_signatures),
+            ) {
+                Ok(plain) => {
+                    ensure!(!ret_valid_signatures.is_empty(), "no valid signatures");
+                    plain
+                }
+                Err(err) => {
+                    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;
 
-        let mut index = 0;
-        let mut decrypted_mime = ptr::null_mut();
-        if unsafe {
-            mailmime_parse(
+            let mut index: libc::size_t = 0;
+            let mut decrypted_mime: *mut Mailmime = ptr::null_mut();
+            if mailmime_parse(
                 plain_buf as *const _,
                 plain_bytes,
                 &mut index,
                 &mut decrypted_mime,
-            )
-        } != MAIL_NO_ERROR as libc::c_int
-            || decrypted_mime.is_null()
-        {
-            if !decrypted_mime.is_null() {
-                unsafe { mailmime_free(decrypted_mime) };
+            ) != MAIL_NO_ERROR as libc::c_int
+                || decrypted_mime.is_null()
+            {
+                if !decrypted_mime.is_null() {
+                    mailmime_free(decrypted_mime);
+                }
+            } else {
+                ret_decrypted_mime = decrypted_mime;
             }
-        } else {
-            // decrypted_mime points into `plain`.
-            // FIXME(@dignifiedquire): this still leaks memory I believe, as mailmime_free
-            // does not free the underlying buffer. But for now we have to live with it
             std::mem::forget(plain);
-            ret_decrypted_mime = decrypted_mime;
         }
+        mmap_string_unref(decoded_data);
     }
-    unsafe { mmap_string_unref(decoded_data) };
-
     Ok(ret_decrypted_mime)
 }
 
-fn has_decrypted_pgp_armor(input: &[u8]) -> bool {
-    if let Some(index) = input.iter().position(|b| *b > b' ') {
-        if input.len() - index > 26 {
-            let start = index;
-            let end = start + 27;
-
-            return &input[start..end] == b"-----BEGIN PGP MESSAGE-----";
+unsafe fn has_decrypted_pgp_armor(str__: *const libc::c_char, mut str_bytes: libc::c_int) -> bool {
+    let str_end: *const libc::c_uchar = (str__ as *const libc::c_uchar).offset(str_bytes as isize);
+    let mut p: *const libc::c_uchar = str__ as *const libc::c_uchar;
+    while p < str_end {
+        if *p as libc::c_int > ' ' as i32 {
+            break;
         }
+        p = p.offset(1isize);
+        str_bytes -= 1
     }
-
-    false
+    str_bytes > 27i32
+        && strncmp(
+            p as *const libc::c_char,
+            b"-----BEGIN PGP MESSAGE-----\x00" as *const u8 as *const libc::c_char,
+            27,
+        ) == 0
 }
 
 /// Check if a MIME structure contains a multipart/report part.
@@ -681,31 +712,29 @@ fn has_decrypted_pgp_armor(input: &[u8]) -> bool {
 /// However, Delta Chat itself has no problem with encrypted multipart/report
 /// parts and MUAs should be encouraged to encrpyt multipart/reports as well so
 /// that we could use the normal Autocrypt processing.
-fn contains_report(mime: *mut Mailmime) -> bool {
-    assert!(!mime.is_null());
-    let mime = unsafe { *mime };
-
-    if mime.mm_type == MAILMIME_MULTIPLE as libc::c_int {
-        let tp_type = unsafe { (*(*mime.mm_content_type).ct_type).tp_type };
-        let ct_type =
-            unsafe { (*(*(*mime.mm_content_type).ct_type).tp_data.tp_composite_type).ct_type };
-
-        if tp_type == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int
-            && ct_type == MAILMIME_COMPOSITE_TYPE_MULTIPART as libc::c_int
-            && as_str(unsafe { (*mime.mm_content_type).ct_subtype }) == "report"
+unsafe fn contains_report(mime: *mut Mailmime) -> bool {
+    if (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int {
+        if (*(*(*mime).mm_content_type).ct_type).tp_type
+            == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int
+            && (*(*(*(*mime).mm_content_type).ct_type)
+                .tp_data
+                .tp_composite_type)
+                .ct_type
+                == MAILMIME_COMPOSITE_TYPE_MULTIPART as libc::c_int
+            && strcmp(
+                (*(*mime).mm_content_type).ct_subtype,
+                b"report\x00" as *const u8 as *const libc::c_char,
+            ) == 0i32
         {
             return true;
         }
-
-        for cur_data in unsafe { (*(*mime.mm_mime_fields).fld_list).into_iter() } {
+        for cur_data in (*(*(*mime).mm_mime_fields).fld_list).into_iter() {
             if contains_report(cur_data as *mut Mailmime) {
                 return true;
             }
         }
-    } else if mime.mm_type == MAILMIME_MESSAGE as libc::c_int {
-        let m = unsafe { mime.mm_data.mm_message.mm_msg_mime };
-
-        if contains_report(m) {
+    } else if (*mime).mm_type == MAILMIME_MESSAGE as libc::c_int {
+        if contains_report((*mime).mm_data.mm_message.mm_msg_mime) {
             return true;
         }
     }
@@ -840,22 +869,4 @@ Sent with my Delta Chat Messenger: https://delta.chat";
             assert_eq!(res0.unwrap(), res1.unwrap());
         }
     }
-
-    #[test]
-    fn test_has_decrypted_pgp_armor() {
-        let data = b" -----BEGIN PGP MESSAGE-----";
-        assert_eq!(has_decrypted_pgp_armor(data), true);
-
-        let data = b"    \n-----BEGIN PGP MESSAGE-----";
-        assert_eq!(has_decrypted_pgp_armor(data), true);
-
-        let data = b"    -----BEGIN PGP MESSAGE---";
-        assert_eq!(has_decrypted_pgp_armor(data), false);
-
-        let data = b" -----BEGIN PGP MESSAGE-----";
-        assert_eq!(has_decrypted_pgp_armor(data), true);
-
-        let data = b"blas";
-        assert_eq!(has_decrypted_pgp_armor(data), false);
-    }
 }

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");
@@ -574,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);
 

src/job.rs

@@ -965,39 +965,41 @@ fn send_mdn(context: &Context, msg_id: u32) {
 
 #[allow(non_snake_case)]
 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 = match context.new_blob_file(&mimefactory.rfc724_mid, bytes) {
-        Ok(path) => path,
-        Err(err) => {
-            error!(
-                context,
-                "Could not write {} smtp-message, error {}", mimefactory.rfc724_mid, err
-            );
-            return 0;
-        }
-    };
-    info!(context, "add_smtp_job file written: {:?}", bpath);
-    let 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,
-    );
-    1
+    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/peerstate.rs

@@ -23,7 +23,7 @@ pub struct Peerstate<'a> {
     pub gossip_key: Option<Key>,
     pub gossip_timestamp: i64,
     pub gossip_key_fingerprint: Option<String>,
-    pub verified_key: Option<Key>,
+    verified_key: VerifiedKey,
     pub verified_key_fingerprint: Option<String>,
     pub to_save: Option<ToSave>,
     pub degrade_event: Option<DegradeEvent>,
@@ -85,6 +85,32 @@ pub enum DegradeEvent {
     FingerprintChanged = 0x02,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum VerifiedKey {
+    Gossip,
+    Public,
+    None,
+}
+
+impl Default for VerifiedKey {
+    fn default() -> Self {
+        VerifiedKey::None
+    }
+}
+
+impl VerifiedKey {
+    pub fn is_none(&self) -> bool {
+        match self {
+            VerifiedKey::None => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_some(&self) -> bool {
+        !self.is_none()
+    }
+}
+
 impl<'a> Peerstate<'a> {
     pub fn new(context: &'a Context) -> Self {
         Peerstate {
@@ -98,13 +124,21 @@ impl<'a> Peerstate<'a> {
             gossip_key: None,
             gossip_key_fingerprint: None,
             gossip_timestamp: 0,
-            verified_key: None,
+            verified_key: Default::default(),
             verified_key_fingerprint: None,
             to_save: None,
             degrade_event: None,
         }
     }
 
+    pub fn verified_key(&self) -> Option<&Key> {
+        match self.verified_key {
+            VerifiedKey::Public => self.public_key.as_ref(),
+            VerifiedKey::Gossip => self.gossip_key.as_ref(),
+            VerifiedKey::None => None,
+        }
+    }
+
     pub fn from_header(context: &'a Context, header: &Aheader, message_time: i64) -> Self {
         let mut res = Self::new(context);
 
@@ -208,11 +242,19 @@ impl<'a> Peerstate<'a> {
                     .get(6)
                     .ok()
                     .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
-                res.verified_key = row
+                let vk = row
                     .get(9)
                     .ok()
                     .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
 
+                res.verified_key = if vk == res.gossip_key && res.gossip_key.is_some() {
+                    VerifiedKey::Gossip
+                } else if vk == res.public_key {
+                    VerifiedKey::Public
+                } else {
+                    VerifiedKey::None
+                };
+
                 Ok(res)
             })
             .ok()
@@ -332,7 +374,7 @@ impl<'a> Peerstate<'a> {
         }
 
         if 0 != min_verified {
-            return self.verified_key.as_ref();
+            return self.verified_key();
         }
         if self.public_key.is_some() {
             return self.public_key.as_ref();
@@ -349,7 +391,7 @@ impl<'a> Peerstate<'a> {
                 && self.public_key_fingerprint.as_ref().unwrap() == fingerprint
             {
                 self.to_save = Some(ToSave::All);
-                self.verified_key = self.public_key.clone();
+                self.verified_key = VerifiedKey::Public;
                 self.verified_key_fingerprint = self.public_key_fingerprint.clone();
                 success = true;
             }
@@ -358,7 +400,7 @@ impl<'a> Peerstate<'a> {
                 && self.gossip_key_fingerprint.as_ref().unwrap() == fingerprint
             {
                 self.to_save = Some(ToSave::All);
-                self.verified_key = self.gossip_key.clone();
+                self.verified_key = VerifiedKey::Gossip;
                 self.verified_key_fingerprint = self.gossip_key_fingerprint.clone();
                 success = true;
             }
@@ -396,7 +438,7 @@ impl<'a> Peerstate<'a> {
                     self.gossip_key.as_ref().map(|k| k.to_bytes()),
                     &self.public_key_fingerprint,
                     &self.gossip_key_fingerprint,
-                    self.verified_key.as_ref().map(|k| k.to_bytes()),
+                    self.verified_key().map(|k| k.to_bytes()),
                     &self.verified_key_fingerprint,
                     &self.addr,
                 ],
@@ -464,7 +506,7 @@ mod tests {
             gossip_key: Some(pub_key.clone()),
             gossip_timestamp: 12,
             gossip_key_fingerprint: Some(pub_key.fingerprint()),
-            verified_key: Some(pub_key.clone()),
+            verified_key: VerifiedKey::Gossip,
             verified_key_fingerprint: Some(pub_key.fingerprint()),
             to_save: Some(ToSave::All),
             degrade_event: None,
@@ -509,7 +551,7 @@ mod tests {
             gossip_key: None,
             gossip_timestamp: 12,
             gossip_key_fingerprint: None,
-            verified_key: None,
+            verified_key: VerifiedKey::None,
             verified_key_fingerprint: None,
             to_save: Some(ToSave::All),
             degrade_event: None,

src/securejoin.rs

@@ -413,7 +413,7 @@ pub fn handle_securejoin_handshake(
                 could_not_establish_secure_connection(
                     context,
                     contact_chat_id,
-                    if mimeparser.encrypted {
+                    if mimeparser.e2ee_helper.encrypted {
                         "No valid signature."
                     } else {
                         "Not encrypted."
@@ -693,16 +693,17 @@ fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Res
  ******************************************************************************/
 
 fn encrypted_and_signed(mimeparser: &MimeParser, expected_fingerprint: impl AsRef<str>) -> bool {
-    if !mimeparser.encrypted {
+    if !mimeparser.e2ee_helper.encrypted {
         warn!(mimeparser.context, "Message not encrypted.",);
         false
-    } else if mimeparser.signatures.len() <= 0 {
+    } else if mimeparser.e2ee_helper.signatures.len() <= 0 {
         warn!(mimeparser.context, "Message not signed.",);
         false
     } else if expected_fingerprint.as_ref().is_empty() {
         warn!(mimeparser.context, "Fingerprint for comparison missing.",);
         false
     } else if !mimeparser
+        .e2ee_helper
         .signatures
         .contains(expected_fingerprint.as_ref())
     {
@@ -717,24 +718,21 @@ fn encrypted_and_signed(mimeparser: &MimeParser, expected_fingerprint: impl AsRe
     }
 }
 
-pub fn handle_degrade_event(context: &Context, peerstate: &Peerstate) -> Result<(), Error> {
+pub fn handle_degrade_event(context: &Context, peerstate: &Peerstate) {
     // - we do not issue an warning for DC_DE_ENCRYPTION_PAUSED as this is quite normal
     // - currently, we do not issue an extra warning for DC_DE_VERIFICATION_LOST - this always comes
     //   together with DC_DE_FINGERPRINT_CHANGED which is logged, the idea is not to bother
     //   with things they cannot fix, so the user is just kicked from the verified group
     //   (and he will know this and can fix this)
     if Some(DegradeEvent::FingerprintChanged) == peerstate.degrade_event {
-        let contact_id: i32 = match context.sql.query_get_value(
-            context,
-            "SELECT id FROM contacts WHERE addr=?;",
-            params![&peerstate.addr],
-        ) {
-            None => bail!(
-                "contact with peerstate.addr {:?} not found",
-                &peerstate.addr
-            ),
-            Some(contact_id) => contact_id,
-        };
+        let contact_id: i32 = context
+            .sql
+            .query_get_value(
+                context,
+                "SELECT id FROM contacts WHERE addr=?;",
+                params![&peerstate.addr],
+            )
+            .unwrap_or_default();
         if contact_id > 0 {
             let (contact_chat_id, _) =
                 chat::create_or_lookup_by_contact_id(context, contact_id as u32, Blocked::Deaddrop)
@@ -750,5 +748,4 @@ pub fn handle_degrade_event(context: &Context, peerstate: &Peerstate) -> Result<
             emit_event!(context, Event::ChatModified(contact_chat_id));
         }
     }
-    Ok(())
 }

src/wrapmime.rs

@@ -36,6 +36,7 @@ pub fn get_ct_subtype(mime: *mut Mailmime) -> Option<String> {
         let ct: *mut mailmime_content = (*mime).mm_content_type;
 
         if !ct.is_null() && !(*ct).ct_subtype.is_null() {
+            println!("ct_subtype: {}", to_string((*ct).ct_subtype));
             Some(to_string((*ct).ct_subtype))
         } else {
             None
@@ -47,12 +48,10 @@ pub fn get_autocrypt_mime(
     mime_undetermined: *mut Mailmime,
 ) -> Result<(*mut Mailmime, *mut Mailmime), Error> {
     /* return Result with two mime pointers:
-
-    First mime pointer is to the multipart-mime message
-    (which is replaced with a decrypted version later)
-
-    Second one is to the encrypted payload.
-    For non-autocrypt message an Error is returned.
+       First mime pointer is to the multipart-mime message
+       (which is replaced with a decrypted version later)
+       Second one is to the encrypted payload.
+       For non-autocrypt message an Error is returned.
     */
     unsafe {
         ensure!(