refactor(imex): almost all unsafe gone here

it's eg used in server-filters for detecting DC messages

.gitignore

@@ -16,6 +16,7 @@ python/.tox
 *.egg-info
 __pycache__
 python/src/deltachat/capi*.so
+python/.venv/
 
 python/liveconfig*
 

deltachat-ffi/src/lib.rs

@@ -275,11 +275,11 @@ pub unsafe extern "C" fn dc_is_open(context: *mut dc_context_t) -> libc::c_int {
         eprintln!("ignoring careless call to dc_is_open()");
         return 0;
     }
-    let ffi_context = &mut *context;
+    let ffi_context = &*context;
     let inner_guard = ffi_context.inner.read().unwrap();
     match *inner_guard {
-        Some(_) => 0,
-        None => 1,
+        Some(_) => 1,
+        None => 0,
     }
 }
 
@@ -1528,9 +1528,17 @@ pub unsafe extern "C" fn dc_imex(
         eprintln!("ignoring careless call to dc_imex()");
         return;
     }
+    let what = match imex::ImexMode::from_i32(what as i32) {
+        Some(what) => what,
+        None => {
+            eprintln!("ignoring invalid argument {} to dc_imex", what);
+            return;
+        }
+    };
+
     let ffi_context = &*context;
     ffi_context
-        .with_inner(|ctx| dc_imex::dc_imex(ctx, what, as_opt_str(param1)))
+        .with_inner(|ctx| imex::imex(ctx, what, as_opt_str(param1)))
         .ok();
 }
 
@@ -1545,7 +1553,7 @@ pub unsafe extern "C" fn dc_imex_has_backup(
     }
     let ffi_context = &*context;
     ffi_context
-        .with_inner(|ctx| match dc_imex::dc_imex_has_backup(ctx, as_str(dir)) {
+        .with_inner(|ctx| match imex::has_backup(ctx, as_str(dir)) {
             Ok(res) => res.strdup(),
             Err(err) => {
                 error!(ctx, "dc_imex_has_backup: {}", err);
@@ -1563,7 +1571,13 @@ pub unsafe extern "C" fn dc_initiate_key_transfer(context: *mut dc_context_t) ->
     }
     let ffi_context = &*context;
     ffi_context
-        .with_inner(|ctx| dc_imex::dc_initiate_key_transfer(ctx))
+        .with_inner(|ctx| match imex::initiate_key_transfer(ctx) {
+            Ok(res) => res.strdup(),
+            Err(err) => {
+                error!(ctx, "dc_initiate_key_transfer(): {}", err);
+                ptr::null_mut()
+            }
+        })
         .unwrap_or_else(|_| ptr::null_mut())
 }
 
@@ -1582,15 +1596,15 @@ pub unsafe extern "C" fn dc_continue_key_transfer(
     }
     let ffi_context = &*context;
     ffi_context
-        .with_inner(|ctx| {
-            match dc_imex::dc_continue_key_transfer(ctx, msg_id, as_str(setup_code)) {
+        .with_inner(
+            |ctx| match imex::continue_key_transfer(ctx, msg_id, as_str(setup_code)) {
                 Ok(()) => 1,
                 Err(err) => {
                     error!(ctx, "dc_continue_key_transfer: {}", err);
                     0
                 }
-            }
-        })
+            },
+        )
         .unwrap_or(0)
 }
 

examples/repl/cmdline.rs

@@ -8,10 +8,10 @@ use deltachat::configure::*;
 use deltachat::constants::*;
 use deltachat::contact::*;
 use deltachat::context::*;
-use deltachat::dc_imex::*;
 use deltachat::dc_receive_imf::*;
 use deltachat::dc_tools::*;
 use deltachat::error::Error;
+use deltachat::imex::*;
 use deltachat::job::*;
 use deltachat::location;
 use deltachat::lot::LotState;
@@ -96,22 +96,13 @@ pub unsafe fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
 fn dc_poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<(), Error> {
     let data = dc_read_file(context, filename)?;
 
-    unsafe {
-        dc_receive_imf(
-            context,
-            data.as_ptr() as *const _,
-            data.len(),
-            "import",
-            0,
-            0,
-        )
-    };
+    unsafe { dc_receive_imf(context, &data, "import", 0, 0) };
     Ok(())
 }
 
 /// Import a file to the database.
 /// For testing, import a folder with eml-files, a single eml-file, e-mail plus public key and so on.
-/// For normal importing, use dc_imex().
+/// For normal importing, use imex().
 ///
 /// @private @memberof Context
 /// @param context The context as created by dc_context_new().
@@ -414,18 +405,13 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                  ============================================="
             ),
         },
-        "initiate-key-transfer" => {
-            let setup_code = dc_initiate_key_transfer(context);
-            if !setup_code.is_null() {
-                println!(
-                    "Setup code for the transferred setup message: {}",
-                    as_str(setup_code),
-                );
-                free(setup_code as *mut libc::c_void);
-            } else {
-                bail!("Failed to generate setup code");
-            };
-        }
+        "initiate-key-transfer" => match initiate_key_transfer(context) {
+            Ok(setup_code) => println!(
+                "Setup code for the transferred setup message: {}",
+                setup_code,
+            ),
+            Err(err) => bail!("Failed to generate setup code: {}", err),
+        },
         "get-setupcodebegin" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
             let msg_id: u32 = arg1.parse()?;
@@ -446,28 +432,28 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                 !arg1.is_empty() && !arg2.is_empty(),
                 "Arguments <msg-id> <setup-code> expected"
             );
-            dc_continue_key_transfer(context, arg1.parse()?, &arg2)?;
+            continue_key_transfer(context, arg1.parse()?, &arg2)?;
         }
         "has-backup" => {
-            dc_imex_has_backup(context, blobdir)?;
+            has_backup(context, blobdir)?;
         }
         "export-backup" => {
-            dc_imex(context, 11, Some(blobdir));
+            imex(context, ImexMode::ExportBackup, Some(blobdir));
         }
         "import-backup" => {
             ensure!(!arg1.is_empty(), "Argument <backup-file> missing.");
-            dc_imex(context, 12, Some(arg1));
+            imex(context, ImexMode::ImportBackup, Some(arg1));
         }
         "export-keys" => {
-            dc_imex(context, 1, Some(blobdir));
+            imex(context, ImexMode::ExportSelfKeys, Some(blobdir));
         }
         "import-keys" => {
-            dc_imex(context, 2, Some(blobdir));
+            imex(context, ImexMode::ImportSelfKeys, Some(blobdir));
         }
         "export-setup" => {
-            let setup_code = dc_create_setup_code(context);
+            let setup_code = create_setup_code(context);
             let file_name = blobdir.join("autocrypt-setup-message.html");
-            let file_content = dc_render_setup_file(context, &setup_code)?;
+            let file_content = render_setup_file(context, &setup_code)?;
             std::fs::write(&file_name, file_content)?;
             println!(
                 "Setup message written to: {}\nSetup code: {}",

mmime/src/display.rs

@@ -0,0 +1,386 @@
+use crate::clist::*;
+
+use crate::mailimf::types::*;
+use crate::mailmime::types::*;
+
+use std::ffi::CStr;
+
+pub unsafe fn display_mime(mut mime: *mut Mailmime) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    println!("{}", (*mime).mm_type);
+
+    match (*mime).mm_type as u32 {
+        MAILMIME_SINGLE => {
+            println!("single part");
+        }
+        MAILMIME_MULTIPLE => {
+            println!("multipart");
+        }
+        MAILMIME_MESSAGE => println!("message"),
+        _ => {}
+    }
+    if !(*mime).mm_mime_fields.is_null() {
+        if !(*(*(*mime).mm_mime_fields).fld_list).first.is_null() {
+            print!("MIME headers begin");
+            display_mime_fields((*mime).mm_mime_fields);
+            println!("MIME headers end");
+        }
+    }
+    display_mime_content((*mime).mm_content_type);
+    match (*mime).mm_type as u32 {
+        MAILMIME_SINGLE => {
+            display_mime_data((*mime).mm_data.mm_single);
+        }
+        MAILMIME_MULTIPLE => {
+            cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
+            while !cur.is_null() {
+                display_mime(
+                    (if !cur.is_null() {
+                        (*cur).data
+                    } else {
+                        0 as *mut libc::c_void
+                    }) as *mut Mailmime,
+                );
+                cur = if !cur.is_null() {
+                    (*cur).next
+                } else {
+                    0 as *mut clistcell
+                }
+            }
+        }
+        MAILMIME_MESSAGE => {
+            if !(*mime).mm_data.mm_message.mm_fields.is_null() {
+                if !(*(*(*mime).mm_data.mm_message.mm_fields).fld_list)
+                    .first
+                    .is_null()
+                {
+                    println!("headers begin");
+                    display_fields((*mime).mm_data.mm_message.mm_fields);
+                    println!("headers end");
+                }
+                if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
+                    display_mime((*mime).mm_data.mm_message.mm_msg_mime);
+                }
+            }
+        }
+        _ => {}
+    };
+}
+
+unsafe fn display_mime_content(mut content_type: *mut mailmime_content) {
+    print!("type: ");
+    display_mime_type((*content_type).ct_type);
+    println!(
+        "/{}",
+        CStr::from_ptr((*content_type).ct_subtype).to_str().unwrap()
+    );
+}
+unsafe fn display_mime_type(mut type_0: *mut mailmime_type) {
+    match (*type_0).tp_type {
+        1 => {
+            display_mime_discrete_type((*type_0).tp_data.tp_discrete_type);
+        }
+        2 => {
+            display_mime_composite_type((*type_0).tp_data.tp_composite_type);
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_composite_type(mut ct: *mut mailmime_composite_type) {
+    match (*ct).ct_type {
+        1 => {
+            print!("message");
+        }
+        2 => {
+            print!("multipart");
+        }
+        3 => {
+            print!("{}", CStr::from_ptr((*ct).ct_token).to_str().unwrap());
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_discrete_type(mut discrete_type: *mut mailmime_discrete_type) {
+    match (*discrete_type).dt_type {
+        1 => {
+            print!("text");
+        }
+        2 => {
+            print!("image");
+        }
+        3 => {
+            print!("audio");
+        }
+        4 => {
+            print!("video");
+        }
+        5 => {
+            print!("application");
+        }
+        6 => {
+            print!("{}", (*discrete_type).dt_extension as u8 as char);
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_data(mut data: *mut mailmime_data) {
+    match (*data).dt_type {
+        0 => {
+            println!(
+                "data : {} bytes",
+                (*data).dt_data.dt_text.dt_length as libc::c_uint,
+            );
+        }
+        1 => {
+            println!(
+                "data (file) : {}",
+                CStr::from_ptr((*data).dt_data.dt_filename)
+                    .to_str()
+                    .unwrap()
+            );
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_dsp_parm(mut param: *mut mailmime_disposition_parm) {
+    match (*param).pa_type {
+        0 => {
+            println!(
+                "filename: {}",
+                CStr::from_ptr((*param).pa_data.pa_filename)
+                    .to_str()
+                    .unwrap()
+            );
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_disposition(mut disposition: *mut mailmime_disposition) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*disposition).dsp_parms).first;
+    while !cur.is_null() {
+        let mut param: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
+        param = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailmime_disposition_parm;
+        display_mime_dsp_parm(param);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_mime_field(mut field: *mut mailmime_field) {
+    match (*field).fld_type {
+        1 => {
+            print!("content-type: ");
+            display_mime_content((*field).fld_data.fld_content);
+            println!("");
+        }
+        6 => {
+            display_mime_disposition((*field).fld_data.fld_disposition);
+        }
+        _ => {}
+    };
+}
+unsafe fn display_mime_fields(mut fields: *mut mailmime_fields) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*fields).fld_list).first;
+    while !cur.is_null() {
+        let mut field: *mut mailmime_field = 0 as *mut mailmime_field;
+        field = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailmime_field;
+        display_mime_field(field);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_date_time(mut d: *mut mailimf_date_time) {
+    print!(
+        "{:02}/{:02}/{:02} {:02}:{:02}:{:02} +{:04}",
+        (*d).dt_day,
+        (*d).dt_month,
+        (*d).dt_year,
+        (*d).dt_hour,
+        (*d).dt_min,
+        (*d).dt_sec,
+        (*d).dt_zone,
+    );
+}
+unsafe fn display_orig_date(mut orig_date: *mut mailimf_orig_date) {
+    display_date_time((*orig_date).dt_date_time);
+}
+unsafe fn display_mailbox(mut mb: *mut mailimf_mailbox) {
+    if !(*mb).mb_display_name.is_null() {
+        print!(
+            "{}",
+            CStr::from_ptr((*mb).mb_display_name).to_str().unwrap()
+        );
+    }
+    print!("<{}>", CStr::from_ptr((*mb).mb_addr_spec).to_str().unwrap());
+}
+unsafe fn display_mailbox_list(mut mb_list: *mut mailimf_mailbox_list) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*mb_list).mb_list).first;
+    while !cur.is_null() {
+        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
+        mb = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_mailbox;
+        display_mailbox(mb);
+        if !if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+        .is_null()
+        {
+            print!(", ");
+        }
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_group(mut group: *mut mailimf_group) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    print!(
+        "{}: ",
+        CStr::from_ptr((*group).grp_display_name).to_str().unwrap()
+    );
+    cur = (*(*(*group).grp_mb_list).mb_list).first;
+    while !cur.is_null() {
+        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
+        mb = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_mailbox;
+        display_mailbox(mb);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+    print!("; ");
+}
+unsafe fn display_address(mut a: *mut mailimf_address) {
+    match (*a).ad_type {
+        2 => {
+            display_group((*a).ad_data.ad_group);
+        }
+        1 => {
+            display_mailbox((*a).ad_data.ad_mailbox);
+        }
+        _ => {}
+    };
+}
+unsafe fn display_address_list(mut addr_list: *mut mailimf_address_list) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*addr_list).ad_list).first;
+    while !cur.is_null() {
+        let mut addr: *mut mailimf_address = 0 as *mut mailimf_address;
+        addr = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_address;
+        display_address(addr);
+        if !if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+        .is_null()
+        {
+            print!(", ");
+        }
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}
+unsafe fn display_from(mut from: *mut mailimf_from) {
+    display_mailbox_list((*from).frm_mb_list);
+}
+unsafe fn display_to(mut to: *mut mailimf_to) {
+    display_address_list((*to).to_addr_list);
+}
+unsafe fn display_cc(mut cc: *mut mailimf_cc) {
+    display_address_list((*cc).cc_addr_list);
+}
+unsafe fn display_subject(mut subject: *mut mailimf_subject) {
+    print!("{}", CStr::from_ptr((*subject).sbj_value).to_str().unwrap());
+}
+unsafe fn display_field(mut field: *mut mailimf_field) {
+    match (*field).fld_type {
+        9 => {
+            print!("Date: ");
+            display_orig_date((*field).fld_data.fld_orig_date);
+            println!("");
+        }
+        10 => {
+            print!("From: ");
+            display_from((*field).fld_data.fld_from);
+            println!("");
+        }
+        13 => {
+            print!("To: ");
+            display_to((*field).fld_data.fld_to);
+            println!("");
+        }
+        14 => {
+            print!("Cc: ");
+            display_cc((*field).fld_data.fld_cc);
+            println!("");
+        }
+        19 => {
+            print!("Subject: ");
+            display_subject((*field).fld_data.fld_subject);
+            println!("");
+        }
+        16 => {
+            println!(
+                "Message-ID: {}",
+                CStr::from_ptr((*(*field).fld_data.fld_message_id).mid_value)
+                    .to_str()
+                    .unwrap(),
+            );
+        }
+        _ => {}
+    };
+}
+unsafe fn display_fields(mut fields: *mut mailimf_fields) {
+    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    cur = (*(*fields).fld_list).first;
+    while !cur.is_null() {
+        let mut f: *mut mailimf_field = 0 as *mut mailimf_field;
+        f = (if !cur.is_null() {
+            (*cur).data
+        } else {
+            0 as *mut libc::c_void
+        }) as *mut mailimf_field;
+        display_field(f);
+        cur = if !cur.is_null() {
+            (*cur).next
+        } else {
+            0 as *mut clistcell
+        }
+    }
+}

mmime/src/lib.rs

@@ -19,6 +19,7 @@
 pub mod charconv;
 pub mod chash;
 pub mod clist;
+pub mod display;
 pub mod mailimf;
 pub mod mailmime;
 pub mod mmapstring;
@@ -27,6 +28,7 @@ pub mod other;
 pub use self::charconv::*;
 pub use self::chash::*;
 pub use self::clist::*;
+pub use self::display::*;
 pub use self::mailimf::*;
 pub use self::mailmime::*;
 pub use self::mmapstring::*;
@@ -35,10 +37,6 @@ pub use self::other::*;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::mailimf::types::*;
-    use crate::mailmime::types::*;
-
-    use std::ffi::CStr;
 
     #[test]
     fn mailmime_parse_test() {
@@ -77,384 +75,4 @@ mod tests {
             mailmime::types::mailmime_free(mime);
         }
     }
-
-    unsafe fn display_mime(mut mime: *mut Mailmime) {
-        let mut cur: *mut clistiter = 0 as *mut clistiter;
-        println!("{}", (*mime).mm_type);
-
-        match (*mime).mm_type {
-            1 => {
-                println!("single part");
-            }
-            2 => {
-                println!("multipart");
-            }
-            3 => println!("message"),
-            _ => {}
-        }
-        if !(*mime).mm_mime_fields.is_null() {
-            if !(*(*(*mime).mm_mime_fields).fld_list).first.is_null() {
-                print!("MIME headers begin");
-                display_mime_fields((*mime).mm_mime_fields);
-                println!("MIME headers end");
-            }
-        }
-        display_mime_content((*mime).mm_content_type);
-        match (*mime).mm_type {
-            1 => {
-                display_mime_data((*mime).mm_data.mm_single);
-            }
-            2 => {
-                cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
-                while !cur.is_null() {
-                    display_mime(
-                        (if !cur.is_null() {
-                            (*cur).data
-                        } else {
-                            0 as *mut libc::c_void
-                        }) as *mut Mailmime,
-                    );
-                    cur = if !cur.is_null() {
-                        (*cur).next
-                    } else {
-                        0 as *mut clistcell
-                    }
-                }
-            }
-            3 => {
-                if !(*mime).mm_data.mm_message.mm_fields.is_null() {
-                    if !(*(*(*mime).mm_data.mm_message.mm_fields).fld_list)
-                        .first
-                        .is_null()
-                    {
-                        println!("headers begin");
-                        display_fields((*mime).mm_data.mm_message.mm_fields);
-                        println!("headers end");
-                    }
-                    if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
-                        display_mime((*mime).mm_data.mm_message.mm_msg_mime);
-                    }
-                }
-            }
-            _ => {}
-        };
-    }
-
-    unsafe fn display_mime_content(mut content_type: *mut mailmime_content) {
-        print!("type: ");
-        display_mime_type((*content_type).ct_type);
-        println!(
-            "/{}",
-            CStr::from_ptr((*content_type).ct_subtype).to_str().unwrap()
-        );
-    }
-    unsafe fn display_mime_type(mut type_0: *mut mailmime_type) {
-        match (*type_0).tp_type {
-            1 => {
-                display_mime_discrete_type((*type_0).tp_data.tp_discrete_type);
-            }
-            2 => {
-                display_mime_composite_type((*type_0).tp_data.tp_composite_type);
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_mime_composite_type(mut ct: *mut mailmime_composite_type) {
-        match (*ct).ct_type {
-            1 => {
-                print!("message");
-            }
-            2 => {
-                print!("multipart");
-            }
-            3 => {
-                print!("{}", CStr::from_ptr((*ct).ct_token).to_str().unwrap());
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_mime_discrete_type(mut discrete_type: *mut mailmime_discrete_type) {
-        match (*discrete_type).dt_type {
-            1 => {
-                print!("text");
-            }
-            2 => {
-                print!("image");
-            }
-            3 => {
-                print!("audio");
-            }
-            4 => {
-                print!("video");
-            }
-            5 => {
-                print!("application");
-            }
-            6 => {
-                print!("{}", (*discrete_type).dt_extension as u8 as char);
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_mime_data(mut data: *mut mailmime_data) {
-        match (*data).dt_type {
-            0 => {
-                println!(
-                    "data : {} bytes",
-                    (*data).dt_data.dt_text.dt_length as libc::c_uint,
-                );
-            }
-            1 => {
-                println!(
-                    "data (file) : {}",
-                    CStr::from_ptr((*data).dt_data.dt_filename)
-                        .to_str()
-                        .unwrap()
-                );
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_mime_dsp_parm(mut param: *mut mailmime_disposition_parm) {
-        match (*param).pa_type {
-            0 => {
-                println!(
-                    "filename: {}",
-                    CStr::from_ptr((*param).pa_data.pa_filename)
-                        .to_str()
-                        .unwrap()
-                );
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_mime_disposition(mut disposition: *mut mailmime_disposition) {
-        let mut cur: *mut clistiter = 0 as *mut clistiter;
-        cur = (*(*disposition).dsp_parms).first;
-        while !cur.is_null() {
-            let mut param: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
-            param = (if !cur.is_null() {
-                (*cur).data
-            } else {
-                0 as *mut libc::c_void
-            }) as *mut mailmime_disposition_parm;
-            display_mime_dsp_parm(param);
-            cur = if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-        }
-    }
-    unsafe fn display_mime_field(mut field: *mut mailmime_field) {
-        match (*field).fld_type {
-            1 => {
-                print!("content-type: ");
-                display_mime_content((*field).fld_data.fld_content);
-                println!("");
-            }
-            6 => {
-                display_mime_disposition((*field).fld_data.fld_disposition);
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_mime_fields(mut fields: *mut mailmime_fields) {
-        let mut cur: *mut clistiter = 0 as *mut clistiter;
-        cur = (*(*fields).fld_list).first;
-        while !cur.is_null() {
-            let mut field: *mut mailmime_field = 0 as *mut mailmime_field;
-            field = (if !cur.is_null() {
-                (*cur).data
-            } else {
-                0 as *mut libc::c_void
-            }) as *mut mailmime_field;
-            display_mime_field(field);
-            cur = if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-        }
-    }
-    unsafe fn display_date_time(mut d: *mut mailimf_date_time) {
-        print!(
-            "{:02}/{:02}/{:02} {:02}:{:02}:{:02} +{:04}",
-            (*d).dt_day,
-            (*d).dt_month,
-            (*d).dt_year,
-            (*d).dt_hour,
-            (*d).dt_min,
-            (*d).dt_sec,
-            (*d).dt_zone,
-        );
-    }
-    unsafe fn display_orig_date(mut orig_date: *mut mailimf_orig_date) {
-        display_date_time((*orig_date).dt_date_time);
-    }
-    unsafe fn display_mailbox(mut mb: *mut mailimf_mailbox) {
-        if !(*mb).mb_display_name.is_null() {
-            print!(
-                "{}",
-                CStr::from_ptr((*mb).mb_display_name).to_str().unwrap()
-            );
-        }
-        print!("<{}>", CStr::from_ptr((*mb).mb_addr_spec).to_str().unwrap());
-    }
-    unsafe fn display_mailbox_list(mut mb_list: *mut mailimf_mailbox_list) {
-        let mut cur: *mut clistiter = 0 as *mut clistiter;
-        cur = (*(*mb_list).mb_list).first;
-        while !cur.is_null() {
-            let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
-            mb = (if !cur.is_null() {
-                (*cur).data
-            } else {
-                0 as *mut libc::c_void
-            }) as *mut mailimf_mailbox;
-            display_mailbox(mb);
-            if !if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-            .is_null()
-            {
-                print!(", ");
-            }
-            cur = if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-        }
-    }
-    unsafe fn display_group(mut group: *mut mailimf_group) {
-        let mut cur: *mut clistiter = 0 as *mut clistiter;
-        print!(
-            "{}: ",
-            CStr::from_ptr((*group).grp_display_name).to_str().unwrap()
-        );
-        cur = (*(*(*group).grp_mb_list).mb_list).first;
-        while !cur.is_null() {
-            let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
-            mb = (if !cur.is_null() {
-                (*cur).data
-            } else {
-                0 as *mut libc::c_void
-            }) as *mut mailimf_mailbox;
-            display_mailbox(mb);
-            cur = if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-        }
-        print!("; ");
-    }
-    unsafe fn display_address(mut a: *mut mailimf_address) {
-        match (*a).ad_type {
-            2 => {
-                display_group((*a).ad_data.ad_group);
-            }
-            1 => {
-                display_mailbox((*a).ad_data.ad_mailbox);
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_address_list(mut addr_list: *mut mailimf_address_list) {
-        let mut cur: *mut clistiter = 0 as *mut clistiter;
-        cur = (*(*addr_list).ad_list).first;
-        while !cur.is_null() {
-            let mut addr: *mut mailimf_address = 0 as *mut mailimf_address;
-            addr = (if !cur.is_null() {
-                (*cur).data
-            } else {
-                0 as *mut libc::c_void
-            }) as *mut mailimf_address;
-            display_address(addr);
-            if !if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-            .is_null()
-            {
-                print!(", ");
-            }
-            cur = if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-        }
-    }
-    unsafe fn display_from(mut from: *mut mailimf_from) {
-        display_mailbox_list((*from).frm_mb_list);
-    }
-    unsafe fn display_to(mut to: *mut mailimf_to) {
-        display_address_list((*to).to_addr_list);
-    }
-    unsafe fn display_cc(mut cc: *mut mailimf_cc) {
-        display_address_list((*cc).cc_addr_list);
-    }
-    unsafe fn display_subject(mut subject: *mut mailimf_subject) {
-        print!("{}", CStr::from_ptr((*subject).sbj_value).to_str().unwrap());
-    }
-    unsafe fn display_field(mut field: *mut mailimf_field) {
-        match (*field).fld_type {
-            9 => {
-                print!("Date: ");
-                display_orig_date((*field).fld_data.fld_orig_date);
-                println!("");
-            }
-            10 => {
-                print!("From: ");
-                display_from((*field).fld_data.fld_from);
-                println!("");
-            }
-            13 => {
-                print!("To: ");
-                display_to((*field).fld_data.fld_to);
-                println!("");
-            }
-            14 => {
-                print!("Cc: ");
-                display_cc((*field).fld_data.fld_cc);
-                println!("");
-            }
-            19 => {
-                print!("Subject: ");
-                display_subject((*field).fld_data.fld_subject);
-                println!("");
-            }
-            16 => {
-                println!(
-                    "Message-ID: {}",
-                    CStr::from_ptr((*(*field).fld_data.fld_message_id).mid_value)
-                        .to_str()
-                        .unwrap(),
-                );
-            }
-            _ => {}
-        };
-    }
-    unsafe fn display_fields(mut fields: *mut mailimf_fields) {
-        let mut cur: *mut clistiter = 0 as *mut clistiter;
-        cur = (*(*fields).fld_list).first;
-        while !cur.is_null() {
-            let mut f: *mut mailimf_field = 0 as *mut mailimf_field;
-            f = (if !cur.is_null() {
-                (*cur).data
-            } else {
-                0 as *mut libc::c_void
-            }) as *mut mailimf_field;
-            display_field(f);
-            cur = if !cur.is_null() {
-                (*cur).next
-            } else {
-                0 as *mut clistcell
-            }
-        }
-    }
 }

proptest-regressions/dc_strencode.txt

@@ -5,3 +5,4 @@
 # It is recommended to check this file in to source control so that
 # everyone who runs the test benefits from these saved cases.
 cc 679506fe9ac59df773f8cfa800fdab5f0a32fe49d2ab370394000a1aa5bc2a72 # shrinks to buf = "%0A"
+cc e34960438edb2426904b44fb4215154e7e2880f2fd1c3183b98bfcc76fec4882 # shrinks to input = " 0"

python/src/deltachat/account.py

@@ -22,7 +22,7 @@ class Account(object):
     by the underlying deltachat c-library.  All public Account methods are
     meant to be memory-safe and return memory-safe objects.
     """
-    def __init__(self, db_path, logid=None, eventlogging=True):
+    def __init__(self, db_path, logid=None, eventlogging=True, debug=True):
         """ initialize account object.
 
         :param db_path: a path to the account database. The database
@@ -30,13 +30,14 @@ class Account(object):
         :param logid: an optional logging prefix that should be used with
                       the default internal logging.
         :param eventlogging: if False no eventlogging and no context callback will be configured
+        :param debug: turn on debug logging for events.
         """
         self._dc_context = ffi.gc(
             lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
             _destroy_dc_context,
         )
         if eventlogging:
-            self._evlogger = EventLogger(self._dc_context, logid)
+            self._evlogger = EventLogger(self._dc_context, logid, debug)
             deltachat.set_context_callback(self._dc_context, self._process_event)
             self._threads = IOThreads(self._dc_context, self._evlogger._log_event)
         else:

python/tests/test_lowlevel.py

@@ -130,3 +130,21 @@ def test_get_info_open(tmpdir):
     info = cutil.from_dc_charpointer(lib.dc_get_info(ctx))
     assert 'deltachat_core_version' in info
     assert 'database_dir' in info
+
+
+def test_is_open_closed():
+    ctx = ffi.gc(
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
+        lib.dc_context_unref,
+    )
+    assert lib.dc_is_open(ctx) == 0
+
+
+def test_is_open_actually_open(tmpdir):
+    ctx = ffi.gc(
+        lib.dc_context_new(lib.py_dc_callback, ffi.NULL, ffi.NULL),
+        lib.dc_context_unref,
+    )
+    db_fname = tmpdir.join("test.db")
+    lib.dc_open(ctx, db_fname.strpath.encode("ascii"), ffi.NULL)
+    assert lib.dc_is_open(ctx) == 1

spec.md

@@ -117,7 +117,8 @@ The sender plus the recipients are the group members.
 To allow different groups with the same members,
 groups are identified by a group-id.
 The group-id MUST be created only from the characters
-`0`-`9`, `A`-`Z`, `a`-`z` `_` and `-`.
+`0`-`9`, `A`-`Z`, `a`-`z` `_` and `-`
+and MUST have a length of at least 11 characters.
 
 Groups MUST have a group-name.
 The group-name is any non-zero-length UTF-8 string.
@@ -144,9 +145,9 @@ The message-id MUST have the format `Gr.<group-id>.<unique data>`.
     From: member1@domain
     To: member2@domain, member3@domain
     Chat-Version: 1.0
-    Chat-Group-ID: 1234xyZ
+    Chat-Group-ID: 12345uvwxyZ
     Chat-Group-Name: My Group
-    Message-ID: Gr.1234xyZ.0001@domain
+    Message-ID: Gr.12345uvwxyZ.0001@domain
     Subject: Chat: My Group: Hello group ...
 
     Hello group - this group contains three members
@@ -196,10 +197,10 @@ and the message SHOULD appear as a message or action from the sender.
     From: member1@domain
     To: member2@domain, member3@domain, member4@domain
     Chat-Version: 1.0
-    Chat-Group-ID: 1234xyZ
+    Chat-Group-ID: 12345uvwxyZ
     Chat-Group-Name: My Group
     Chat-Group-Member-Added: member4@domain
-    Message-ID: Gr.1234xyZ.0002@domain
+    Message-ID: Gr.12345uvwxyZ.0002@domain
     Subject: Chat: My Group: Hello, ...
 
     Hello, I've added member4@domain to our group.  Now we have 4 members.
@@ -209,10 +210,10 @@ To remove a member:
     From: member1@domain
     To: member2@domain, member3@domain
     Chat-Version: 1.0
-    Chat-Group-ID: 1234xyZ
+    Chat-Group-ID: 12345uvwxyZ
     Chat-Group-Name: My Group
     Chat-Group-Member-Removed: member4@domain
-    Message-ID: Gr.1234xyZ.0003@domain
+    Message-ID: Gr.12345uvwxyZ.0003@domain
     Subject: Chat: My Group: Hello, ...
 
     Hello, I've removed member4@domain from our group.  Now we have 3 members.
@@ -233,10 +234,10 @@ and the message SHOULD appear as a message or action from the sender.
     From: member1@domain
     To: member2@domain, member3@domain
     Chat-Version: 1.0
-    Chat-Group-ID: 1234xyZ
+    Chat-Group-ID: 12345uvwxyZ
     Chat-Group-Name: Our Group
     Chat-Group-Name-Changed: My Group
-    Message-ID: Gr.1234xyZ.0004@domain
+    Message-ID: Gr.12345uvwxyZ.0004@domain
     Subject: Chat: Our Group: Hello, ...
 
     Hello, I've changed the group name from "My Group" to "Our Group".
@@ -262,10 +263,10 @@ and the message SHOULD appear as a message or action from the sender.
     From: member1@domain
     To: member2@domain, member3@domain
     Chat-Version: 1.0
-    Chat-Group-ID: 1234xyZ
+    Chat-Group-ID: 12345uvwxyZ
     Chat-Group-Name: Our Group
     Chat-Group-Image: image.jpg
-    Message-ID: Gr.1234xyZ.0005@domain
+    Message-ID: Gr.12345uvwxyZ.0005@domain
     Subject: Chat: Our Group: Hello, ...
     Content-Type: multipart/mixed; boundary="==break=="
 

src/constants.rs

@@ -64,15 +64,6 @@ pub const DC_GCL_ADD_SELF: usize = 0x02;
 pub(crate) const DC_FP_NO_AUTOCRYPT_HEADER: i32 = 2;
 pub(crate) const DC_FP_ADD_AUTOCRYPT_HEADER: i32 = 1;
 
-/// param1 is a directory where the keys are written to
-pub const DC_IMEX_EXPORT_SELF_KEYS: i32 = 1;
-/// param1 is a directory where the keys are searched in and read from
-pub const DC_IMEX_IMPORT_SELF_KEYS: i32 = 2;
-/// param1 is a directory where the backup is written to
-pub const DC_IMEX_EXPORT_BACKUP: i32 = 11;
-/// param1 is the file with the backup to import
-pub const DC_IMEX_IMPORT_BACKUP: i32 = 12;
-
 /// virtual chat showing all messages belonging to chats flagged with chats.blocked=2
 pub(crate) const DC_CHAT_ID_DEADDROP: u32 = 1;
 /// messages that should be deleted get this chat_id; the messages are deleted from the working thread later then. This is also needed as rfc724_mid should be preset as long as the message is not deleted on the server (otherwise it is downloaded again)

src/dc_mimeparser.rs

@@ -102,7 +102,7 @@ impl<'a> MimeParser<'a> {
         }
     }
 
-    pub unsafe fn parse(&mut self, body: &[u8]) {
+    pub unsafe fn parse(&mut self, body: &[u8]) -> Result<(), Error> {
         let mut index = 0;
 
         let r = mailmime_parse(
@@ -113,7 +113,7 @@ impl<'a> MimeParser<'a> {
         );
 
         if r == MAILIMF_NO_ERROR as libc::c_int && !self.mimeroot.is_null() {
-            self.e2ee_helper.decrypt(self.context, self.mimeroot);
+            self.e2ee_helper.try_decrypt(self.context, self.mimeroot)?;
             self.parse_mime_recursive(self.mimeroot);
 
             if let Some(field) = self.lookup_field("Subject") {
@@ -317,6 +317,7 @@ impl<'a> MimeParser<'a> {
             }
             self.parts.push(part_5);
         }
+        Ok(())
     }
 
     pub fn get_last_nonmeta(&mut self) -> Option<&mut Part> {
@@ -889,7 +890,6 @@ impl<'a> Drop for MimeParser<'a> {
         if !self.mimeroot.is_null() {
             unsafe { mailmime_free(self.mimeroot) };
         }
-        unsafe { self.e2ee_helper.thanks() };
     }
 }
 
@@ -1056,7 +1056,8 @@ unsafe fn mailmime_get_mime_type(mime: *mut Mailmime) -> (libc::c_int, Viewtype,
                     Some("alternative") => DC_MIMETYPE_MP_ALTERNATIVE,
                     Some("related") => DC_MIMETYPE_MP_RELATED,
                     Some("encrypted") => {
-                        // decryptable parts are already converted to other mime parts in dc_e2ee_decrypt()
+                        // maybe try_decrypt failed to decrypt
+                        // or it wasn't in proper Autocrypt format
                         DC_MIMETYPE_MP_NOT_DECRYPTABLE
                     }
                     Some("signed") => DC_MIMETYPE_MP_SIGNED,
@@ -1422,12 +1423,11 @@ mod tests {
     }
 
     #[test]
-    #[ignore]
     fn test_dc_mimeparser_crash() {
         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[..]) };
+        unsafe { mimeparser.parse(&raw[..]).unwrap() };
         assert_eq!(mimeparser.subject, None);
         assert_eq!(mimeparser.parts.len(), 1);
     }
@@ -1437,7 +1437,7 @@ mod tests {
         fn test_dc_mailmime_parse_crash_fuzzy(data in "[!-~\t ]{2000,}") {
             let context = dummy_context();
             let mut mimeparser = MimeParser::new(&context.ctx);
-            unsafe { mimeparser.parse(data.as_bytes()) };
+            unsafe { mimeparser.parse(data.as_bytes()).unwrap() };
         }
     }
 
@@ -1446,7 +1446,7 @@ mod tests {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/mail_with_message_id.txt");
         let mut mimeparser = MimeParser::new(&context.ctx);
-        unsafe { mimeparser.parse(&raw[..]) };
+        unsafe { mimeparser.parse(&raw[..]).unwrap() };
         assert_eq!(
             mimeparser.get_rfc724_mid(),
             Some("2dfdbde7@example.org".into())
@@ -1458,7 +1458,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[..]) };
+        unsafe { mimeparser.parse(&raw[..]).unwrap() };
         assert_eq!(mimeparser.get_rfc724_mid(), None);
     }
 
@@ -1468,7 +1468,7 @@ mod tests {
             let context = dummy_context();
             let raw = b"Content-Type: multipart/mixed; boundary=\"==break==\";\nSubject: outer-subject\nX-Special-A: special-a\nFoo: Bar\nChat-Version: 0.0\n\n--==break==\nContent-Type: text/plain; protected-headers=\"v1\";\nSubject: inner-subject\nX-Special-B: special-b\nFoo: Xy\nChat-Version: 1.0\n\ntest1\n\n--==break==--\n\n\x00";
             let mut mimeparser = MimeParser::new(&context.ctx);
-            mimeparser.parse(&raw[..]);
+            mimeparser.parse(&raw[..]).unwrap();
 
             assert_eq!(mimeparser.subject, Some("inner-subject".into()));
 

src/dc_receive_imf.rs

@@ -39,8 +39,7 @@ enum CreateEvent {
 /// Receive a message and add it to the database.
 pub unsafe fn dc_receive_imf(
     context: &Context,
-    imf_raw_not_terminated: *const libc::c_char,
-    imf_raw_bytes: libc::size_t,
+    imf_raw: &[u8],
     server_folder: impl AsRef<str>,
     server_uid: u32,
     flags: u32,
@@ -61,9 +60,10 @@ pub unsafe fn dc_receive_imf(
     // we use mailmime_parse() through dc_mimeparser (both call mailimf_struct_multiple_parse()
     // somewhen, I did not found out anything that speaks against this approach yet)
 
-    let body = std::slice::from_raw_parts(imf_raw_not_terminated as *const u8, imf_raw_bytes);
     let mut mime_parser = MimeParser::new(context);
-    mime_parser.parse(body);
+    if let Err(err) = mime_parser.parse(imf_raw) {
+        error!(context, "dc_receive_imf parse error: {}", err);
+    };
 
     if mime_parser.header.is_empty() {
         // Error - even adding an empty record won't help as we do not know the message ID
@@ -204,8 +204,7 @@ pub unsafe fn dc_receive_imf(
         if let Err(err) = add_parts(
             context,
             &mut mime_parser,
-            imf_raw_not_terminated,
-            imf_raw_bytes,
+            imf_raw,
             incoming,
             &mut incoming_origin,
             server_folder.as_ref(),
@@ -292,8 +291,7 @@ pub unsafe fn dc_receive_imf(
 unsafe fn add_parts(
     context: &Context,
     mut mime_parser: &mut MimeParser,
-    imf_raw_not_terminated: *const libc::c_char,
-    imf_raw_bytes: libc::size_t,
+    imf_raw: &[u8],
     incoming: i32,
     incoming_origin: &mut Origin,
     server_folder: impl AsRef<str>,
@@ -683,10 +681,7 @@ unsafe fn add_parts(
                         part.bytes,
                         *hidden,
                         if save_mime_headers {
-                            Some(String::from_utf8_lossy(std::slice::from_raw_parts(
-                                imf_raw_not_terminated as *const u8,
-                                imf_raw_bytes,
-                            )))
+                            Some(String::from_utf8_lossy(imf_raw))
                         } else {
                             None
                         },
@@ -1155,21 +1150,15 @@ unsafe fn create_or_lookup_group(
     // check, if we have a chat with this group ID
     let (mut chat_id, chat_id_verified, _blocked) = chat::get_chat_id_by_grpid(context, &grpid);
     if chat_id != 0 {
-        let mut failure_reason = std::ptr::null_mut();
-
-        if chat_id_verified
-            && 0 == check_verified_properties(
-                context,
-                mime_parser,
-                from_id as u32,
-                to_ids,
-                &mut failure_reason,
-            )
-        {
-            mime_parser.repl_msg_by_error(to_string(failure_reason));
+        if chat_id_verified {
+            if let Err(err) =
+                check_verified_properties(context, mime_parser, from_id as u32, to_ids)
+            {
+                warn!(context, "verification problem: {}", err);
+                let s = format!("{}. See 'Info' for more details", err);
+                mime_parser.repl_msg_by_error(s);
+            }
         }
-
-        free(failure_reason.cast());
     }
 
     // check if the sender is a member of the existing group -
@@ -1198,18 +1187,14 @@ unsafe fn create_or_lookup_group(
         let mut create_verified = VerifiedStatus::Unverified;
         if mime_parser.lookup_field("Chat-Verified").is_some() {
             create_verified = VerifiedStatus::Verified;
-            let mut failure_reason = std::ptr::null_mut();
 
-            if 0 == check_verified_properties(
-                context,
-                mime_parser,
-                from_id as u32,
-                to_ids,
-                &mut failure_reason,
-            ) {
-                mime_parser.repl_msg_by_error(to_string(failure_reason));
+            if let Err(err) =
+                check_verified_properties(context, mime_parser, from_id as u32, to_ids)
+            {
+                warn!(context, "verification problem: {}", err);
+                let s = format!("{}. See 'Info' for more details", err);
+                mime_parser.repl_msg_by_error(&s);
             }
-            free(failure_reason.cast());
         }
         if 0 == allow_creation {
             cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
@@ -1616,51 +1601,41 @@ fn search_chat_ids_by_contact_ids(context: &Context, unsorted_contact_ids: &Vec<
     chat_ids
 }
 
-unsafe fn check_verified_properties(
+fn check_verified_properties(
     context: &Context,
     mimeparser: &MimeParser,
     from_id: u32,
     to_ids: &Vec<u32>,
-    failure_reason: *mut *mut libc::c_char,
-) -> libc::c_int {
-    let verify_fail = |reason: String| {
-        *failure_reason = format!("{}. See \"Info\" for details.", reason).strdup();
-        warn!(context, "{}", reason);
-    };
+) -> Result<()> {
+    let contact = Contact::load_from_db(context, from_id)?;
 
-    let contact = match Contact::load_from_db(context, from_id) {
-        Ok(contact) => contact,
-        Err(_err) => {
-            verify_fail("Internal Error; cannot load contact".into());
-            return 0;
-        }
-    };
-
-    if !mimeparser.e2ee_helper.encrypted {
-        verify_fail("This message is not encrypted".into());
-        return 0;
-    }
+    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.
     // this check is skipped for SELF as there is no proper SELF-peerstate
     // and results in group-splits otherwise.
-    if from_id != 1 {
+    if from_id != DC_CONTACT_ID_SELF {
         let peerstate = Peerstate::from_addr(context, &context.sql, contact.get_addr());
 
         if peerstate.is_none()
             || contact.is_verified_ex(context, peerstate.as_ref())
                 != VerifiedStatus::BidirectVerified
         {
-            verify_fail("The sender of this message is not verified.".into());
-            return 0;
+            bail!(
+                "Sender of this message is not verified: {}",
+                contact.get_addr()
+            );
         }
 
         if let Some(peerstate) = peerstate {
-            if !peerstate.has_verified_key(&mimeparser.e2ee_helper.signatures) {
-                verify_fail("The message was sent with non-verified encryption.".into());
-                return 0;
-            }
+            ensure!(
+                peerstate.has_verified_key(&mimeparser.e2ee_helper.signatures),
+                "The message was sent with non-verified encryption."
+            );
         }
     }
 
@@ -1673,18 +1648,18 @@ unsafe fn check_verified_properties(
             to_ids_str,
         ),
         params![],
-        |row| Ok((row.get::<_, String>(0)?, row.get::<_, i32>(1)?)),
+        |row| Ok((row.get::<_, String>(0)?, row.get::<_, i32>(1).unwrap_or(0))),
         |rows| {
             rows.collect::<std::result::Result<Vec<_>, _>>()
                 .map_err(Into::into)
         },
-    );
+    )?;
 
-    if rows.is_err() {
-        return 0;
-    }
-    for (to_addr, mut is_verified) in rows.unwrap().into_iter() {
+    for (to_addr, _is_verified) in rows.into_iter() {
+        let mut is_verified = _is_verified != 0;
         let mut peerstate = Peerstate::from_addr(context, &context.sql, &to_addr);
+
+        // mark gossiped keys (if any) as verified
         if mimeparser.e2ee_helper.gossipped_addr.contains(&to_addr) && peerstate.is_some() {
             let peerstate = peerstate.as_mut().unwrap();
 
@@ -1693,29 +1668,27 @@ unsafe fn check_verified_properties(
             // - OR if the verified-key does not match public-key or gossip-key
             //   (otherwise a verified key can _only_ be updated through QR scan which might be annoying,
             //   see https://github.com/nextleap-project/countermitm/issues/46 for a discussion about this point)
-            if 0 == is_verified
+            if !is_verified
                 || peerstate.verified_key_fingerprint != peerstate.public_key_fingerprint
                     && peerstate.verified_key_fingerprint != peerstate.gossip_key_fingerprint
             {
-                info!(context, "{} has verfied {}.", contact.get_addr(), to_addr,);
+                info!(context, "{} has verified {}.", contact.get_addr(), to_addr,);
                 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);
-                    is_verified = 1;
+                    peerstate.save_to_db(&context.sql, false).unwrap();
+                    is_verified = true;
                 }
             }
         }
-        if 0 == is_verified {
-            verify_fail(format!(
+        if !is_verified {
+            bail!(
                 "{} is not a member of this verified group",
-                to_addr
-            ));
-            return 0;
+                to_addr.to_string()
+            );
         }
     }
-
-    1
+    Ok(())
 }
 
 fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {

src/dc_strencode.rs

@@ -1,3 +1,4 @@
+use itertools::Itertools;
 use std::borrow::Cow;
 use std::ffi::CString;
 use std::ptr;
@@ -5,7 +6,6 @@ use std::ptr;
 use charset::Charset;
 use libc::{free, strlen};
 use mmime::mailmime::decode::mailmime_encoded_phrase_parse;
-use mmime::mmapstring::*;
 use mmime::other::*;
 use percent_encoding::{percent_decode, utf8_percent_encode, AsciiSet, CONTROLS};
 
@@ -25,195 +25,49 @@ use crate::dc_tools::*;
  * @return Returns the encoded string which must be free()'d when no longed needed.
  *     On errors, NULL is returned.
  */
-pub unsafe fn dc_encode_header_words(to_encode_r: impl AsRef<str>) -> String {
-    let to_encode =
-        CString::new(to_encode_r.as_ref().as_bytes()).expect("invalid cstring to_encode");
-
-    let mut ok_to_continue = true;
-    let mut ret_str: *mut libc::c_char = ptr::null_mut();
-    let mut cur: *const libc::c_char = to_encode.as_ptr();
-    let mmapstr: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
-    if mmapstr.is_null() {
-        ok_to_continue = false;
-    }
-    loop {
-        if !ok_to_continue {
-            if !mmapstr.is_null() {
-                mmap_string_free(mmapstr);
-            }
-            break;
-        } else {
-            if *cur as libc::c_int != '\u{0}' as i32 {
-                let begin: *const libc::c_char;
-                let mut end: *const libc::c_char;
-                let mut do_quote: bool;
-                let mut quote_words: libc::c_int;
-                begin = cur;
-                end = begin;
-                quote_words = 0i32;
-                do_quote = true;
-                while *cur as libc::c_int != '\u{0}' as i32 {
-                    get_word(cur, &mut cur, &mut do_quote);
-                    if !do_quote {
-                        break;
-                    }
-                    quote_words = 1i32;
-                    end = cur;
-                    if *cur as libc::c_int != '\u{0}' as i32 {
-                        cur = cur.offset(1isize)
-                    }
-                }
-                if 0 != quote_words {
-                    if !quote_word(
-                        mmapstr,
-                        begin,
-                        end.wrapping_offset_from(begin) as libc::size_t,
-                    ) {
-                        ok_to_continue = false;
-                        continue;
-                    }
-                    if *end as libc::c_int == ' ' as i32 || *end as libc::c_int == '\t' as i32 {
-                        if mmap_string_append_c(mmapstr, *end).is_null() {
-                            ok_to_continue = false;
-                            continue;
-                        }
-                        end = end.offset(1isize)
-                    }
-                    if *end as libc::c_int != '\u{0}' as i32 {
-                        if mmap_string_append_len(
-                            mmapstr,
-                            end,
-                            cur.wrapping_offset_from(end) as libc::size_t,
-                        )
-                        .is_null()
-                        {
-                            ok_to_continue = false;
-                            continue;
-                        }
-                    }
-                } else if mmap_string_append_len(
-                    mmapstr,
-                    begin,
-                    cur.wrapping_offset_from(begin) as libc::size_t,
-                )
-                .is_null()
-                {
-                    ok_to_continue = false;
-                    continue;
-                }
-                if !(*cur as libc::c_int == ' ' as i32 || *cur as libc::c_int == '\t' as i32) {
-                    continue;
-                }
-                if mmap_string_append_c(mmapstr, *cur).is_null() {
-                    ok_to_continue = false;
-                    continue;
-                }
-                cur = cur.offset(1isize);
-            } else {
-                ret_str = strdup((*mmapstr).str_0);
-                ok_to_continue = false;
-            }
-        }
+pub fn dc_encode_header_words(input: impl AsRef<str>) -> String {
+    let mut result = String::default();
+    for (_, group) in &input.as_ref().chars().group_by(|c| c.is_whitespace()) {
+        let word: String = group.collect();
+        result.push_str(&quote_word(&word.as_bytes()));
     }
 
-    let s = to_string(ret_str);
-    free(ret_str.cast());
-    s
+    result
 }
 
-unsafe fn quote_word(
-    mmapstr: *mut MMAPString,
-    word: *const libc::c_char,
-    size: libc::size_t,
-) -> bool {
-    let mut cur: *const libc::c_char;
-    let mut i = 0;
-    let mut hex: [libc::c_char; 4] = [0; 4];
-    // let mut col: libc::c_int = 0i32;
-    if mmap_string_append(mmapstr, b"=?utf-8?Q?\x00".as_ptr().cast()).is_null() {
-        return false;
-    }
+fn must_encode(byte: u8) -> bool {
+    static SPECIALS: &[u8] = b",:!\"#$@[\\]^`{|}~=?_";
 
-    // col = (*mmapstr).len as libc::c_int;
-    cur = word;
-    while i < size {
-        let mut do_quote_char = false;
-        match *cur as u8 as char {
-            ',' | ':' | '!' | '"' | '#' | '$' | '@' | '[' | '\\' | ']' | '^' | '`' | '{' | '|'
-            | '}' | '~' | '=' | '?' | '_' => do_quote_char = true,
-            _ => {
-                if *cur as u8 >= 128 {
-                    do_quote_char = true;
-                }
-            }
-        }
-        if do_quote_char {
-            print_hex(hex.as_mut_ptr(), cur);
-            if mmap_string_append(mmapstr, hex.as_mut_ptr()).is_null() {
-                return false;
-            }
-        // col += 3i32
-        } else {
-            if *cur as libc::c_int == ' ' as i32 {
-                if mmap_string_append_c(mmapstr, '_' as i32 as libc::c_char).is_null() {
-                    return false;
-                }
-            } else if mmap_string_append_c(mmapstr, *cur).is_null() {
-                return false;
-            }
-            // col += 3i32
-        }
-        cur = cur.offset(1isize);
-        i = i.wrapping_add(1)
-    }
-    if mmap_string_append(mmapstr, b"?=\x00" as *const u8 as *const libc::c_char).is_null() {
-        return false;
-    }
-
-    true
+    SPECIALS.into_iter().any(|b| *b == byte)
 }
 
-unsafe fn get_word(
-    begin: *const libc::c_char,
-    pend: *mut *const libc::c_char,
-    pto_be_quoted: *mut bool,
-) {
-    let mut cur: *const libc::c_char = begin;
-    while *cur as libc::c_int != ' ' as i32
-        && *cur as libc::c_int != '\t' as i32
-        && *cur as libc::c_int != '\u{0}' as i32
-    {
-        cur = cur.offset(1isize)
+fn quote_word(word: &[u8]) -> String {
+    let mut result = String::default();
+    let mut encoded = false;
+
+    for byte in word {
+        let byte = *byte;
+        if byte >= 128 || must_encode(byte) {
+            result.push_str(&format!("={:2X}", byte));
+            encoded = true;
+        } else if byte == b' ' {
+            result.push('_');
+            encoded = true;
+        } else {
+            result.push(byte as _);
+        }
     }
-    *pto_be_quoted = to_be_quoted(begin, cur.wrapping_offset_from(begin) as libc::size_t);
-    *pend = cur;
+
+    if encoded {
+        result = format!("=?utf-8?Q?{}?=", &result);
+    }
+    result
 }
 
 /* ******************************************************************************
  * Encode/decode header words, RFC 2047
  ******************************************************************************/
 
-/* see comment below */
-unsafe fn to_be_quoted(word: *const libc::c_char, size: libc::size_t) -> bool {
-    let mut cur: *const libc::c_char = word;
-    let mut i = 0;
-    while i < size {
-        match *cur as libc::c_int {
-            44 | 58 | 33 | 34 | 35 | 36 | 64 | 91 | 92 | 93 | 94 | 96 | 123 | 124 | 125 | 126
-            | 61 | 63 | 95 => return true,
-            _ => {
-                if *cur as libc::c_uchar as libc::c_int >= 128i32 {
-                    return true;
-                }
-            }
-        }
-        cur = cur.offset(1isize);
-        i = i.wrapping_add(1)
-    }
-
-    false
-}
-
 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();
@@ -319,15 +173,6 @@ pub fn dc_decode_ext_header(to_decode: &[u8]) -> Cow<str> {
     String::from_utf8_lossy(to_decode)
 }
 
-unsafe fn print_hex(target: *mut libc::c_char, cur: *const libc::c_char) {
-    assert!(!target.is_null());
-    assert!(!cur.is_null());
-
-    let bytes = std::slice::from_raw_parts(cur as *const _, strlen(cur));
-    let raw = CString::yolo(format!("={}", &hex::encode_upper(bytes)[..2]));
-    libc::memcpy(target as *mut _, raw.as_ptr() as *const _, 4);
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -429,18 +274,6 @@ mod tests {
         assert_eq!(dc_needs_ext_header("a b"), true);
     }
 
-    #[test]
-    fn test_print_hex() {
-        let mut hex: [libc::c_char; 4] = [0; 4];
-        let cur = b"helloworld" as *const u8 as *const libc::c_char;
-        unsafe { print_hex(hex.as_mut_ptr(), cur) };
-        assert_eq!(to_string(hex.as_ptr() as *const _), "=68");
-
-        let cur = b":" as *const u8 as *const libc::c_char;
-        unsafe { print_hex(hex.as_mut_ptr(), cur) };
-        assert_eq!(to_string(hex.as_ptr() as *const _), "=3A");
-    }
-
     use proptest::prelude::*;
 
     proptest! {
@@ -456,5 +289,13 @@ mod tests {
             // make sure this never panics
             let _decoded = dc_decode_ext_header(&buf);
         }
+
+        #[test]
+        fn test_dc_header_roundtrip(input: String) {
+            let encoded = dc_encode_header_words(&input);
+            let decoded = dc_decode_header_words_safe(&encoded);
+
+            assert_eq!(input, decoded);
+        }
     }
 }

src/dc_tools.rs

@@ -9,7 +9,7 @@ use std::time::SystemTime;
 use std::{fmt, fs, ptr};
 
 use chrono::{Local, TimeZone};
-use libc::{memcpy, strcpy, strlen, uintptr_t};
+use libc::{memcpy, strlen};
 use mmime::clist::*;
 use mmime::mailimf::types::*;
 use rand::{thread_rng, Rng};
@@ -149,66 +149,6 @@ pub(crate) fn dc_truncate(buf: &str, approx_chars: usize, do_unwrap: bool) -> Co
     }
 }
 
-#[allow(non_snake_case)]
-pub(crate) unsafe fn dc_truncate_n_unwrap_str(
-    buf: *mut libc::c_char,
-    approx_characters: libc::c_int,
-    do_unwrap: libc::c_int,
-) {
-    /* Function unwraps the given string and removes unnecessary whitespace.
-    Function stops processing after approx_characters are processed.
-    (as we're using UTF-8, for simplicity, we cut the string only at whitespaces). */
-    /* a single line is truncated `...` instead of `[...]` (the former is typically also used by the UI to fit strings in a rectangle) */
-    let ellipse_utf8: *const libc::c_char = if 0 != do_unwrap {
-        b" ...\x00" as *const u8 as *const libc::c_char
-    } else {
-        b" [...]\x00" as *const u8 as *const libc::c_char
-    };
-    let mut lastIsCharacter: libc::c_int = 0;
-    /* force unsigned - otherwise the `> ' '` comparison will fail */
-    let mut p1: *mut libc::c_uchar = buf as *mut libc::c_uchar;
-    while 0 != *p1 {
-        if *p1 as libc::c_int > ' ' as i32 {
-            lastIsCharacter = 1
-        } else if 0 != lastIsCharacter {
-            let used_bytes = (p1 as uintptr_t).wrapping_sub(buf as uintptr_t) as libc::size_t;
-            if dc_utf8_strnlen(buf, used_bytes) >= approx_characters as usize {
-                let buf_bytes = strlen(buf);
-                if buf_bytes.wrapping_sub(used_bytes) >= strlen(ellipse_utf8) {
-                    strcpy(p1 as *mut libc::c_char, ellipse_utf8);
-                }
-                break;
-            } else {
-                lastIsCharacter = 0;
-                if 0 != do_unwrap {
-                    *p1 = ' ' as i32 as libc::c_uchar
-                }
-            }
-        } else if 0 != do_unwrap {
-            *p1 = '\r' as i32 as libc::c_uchar
-        }
-        p1 = p1.offset(1isize)
-    }
-    if 0 != do_unwrap {
-        dc_remove_cr_chars(buf);
-    };
-}
-
-unsafe fn dc_utf8_strnlen(s: *const libc::c_char, n: libc::size_t) -> libc::size_t {
-    if s.is_null() {
-        return 0;
-    }
-
-    let mut j: libc::size_t = 0;
-    for i in 0..n {
-        if *s.add(i) as libc::c_int & 0xc0 != 0x80 {
-            j = j.wrapping_add(1)
-        }
-    }
-
-    j
-}
-
 pub(crate) unsafe fn dc_str_from_clist(
     list: *const clist,
     delimiter: *const libc::c_char,

src/e2ee.rs

@@ -1,12 +1,11 @@
 //! End-to-end encryption support.
 
-use std::any::Any;
 use std::collections::HashSet;
 use std::ffi::CStr;
 use std::ptr;
 use std::str::FromStr;
 
-use libc::{free, strcmp, strlen, strncmp};
+use libc::{strcmp, strlen, strncmp};
 use mmime::clist::*;
 use mmime::mailimf::types::*;
 use mmime::mailimf::types_helper::*;
@@ -182,7 +181,8 @@ impl EncryptHelper {
                         let opt_field = (*field).fld_data.fld_optional_field;
                         if !opt_field.is_null() && !(*opt_field).fld_name.is_null() {
                             let fld_name = to_string_lossy((*opt_field).fld_name);
-                            if fld_name.starts_with("Secure-Join") || fld_name.starts_with("Chat-")
+                            if fld_name.starts_with("Secure-Join")
+                                || (fld_name.starts_with("Chat-") && fld_name != "Chat-Version")
                             {
                                 move_to_encrypted = true;
                             }
@@ -287,8 +287,6 @@ impl EncryptHelper {
 
 #[derive(Debug, Default)]
 pub struct E2eeHelper {
-    cdata_to_free: Option<Box<dyn Any>>,
-
     // for decrypting only
     pub encrypted: bool,
     pub signatures: HashSet<String>,
@@ -296,17 +294,11 @@ pub struct E2eeHelper {
 }
 
 impl E2eeHelper {
-    /// Frees data referenced by "mailmime" but not freed by mailmime_free(). After calling this function,
-    /// in_out_message cannot be used any longer!
-    pub unsafe fn thanks(&mut self) {
-        if let Some(data) = self.cdata_to_free.take() {
-            free(Box::into_raw(data) as *mut _)
-        }
-    }
-
-    pub unsafe fn decrypt(&mut self, context: &Context, in_out_message: *mut Mailmime) {
-        /* return values: 0=nothing to decrypt/cannot decrypt, 1=sth. decrypted
-        (to detect parts that could not be decrypted, simply look for left "multipart/encrypted" MIME types */
+    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;
@@ -314,6 +306,8 @@ impl E2eeHelper {
         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);
 
@@ -342,16 +336,16 @@ impl E2eeHelper {
                     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);
+                            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);
+                            peerstate.save_to_db(&context.sql, false).unwrap();
                         }
                     } else if let Some(ref header) = autocryptheader {
                         let p = Peerstate::from_header(context, header, message_time);
-                        assert!(p.save_to_db(&context.sql, true));
+                        p.save_to_db(&context.sql, true).unwrap();
                         peerstate = Some(p);
                     }
                 }
@@ -379,30 +373,22 @@ impl E2eeHelper {
                             public_keyring_for_validate.add_ref(key);
                         }
                     }
-                    for iterations in 0..10 {
-                        let mut has_unencrypted_parts: libc::c_int = 0i32;
-                        if decrypt_recursive(
-                            context,
-                            in_out_message,
-                            &private_keyring,
-                            &public_keyring_for_validate,
-                            &mut self.signatures,
-                            &mut gossip_headers,
-                            &mut has_unencrypted_parts,
-                        )
-                        .is_err()
-                        {
-                            break;
+
+                    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;
                         }
-                        /* if we're here, sth. was encrypted. if we're on top-level,
-                        and there are no additional unencrypted parts in the message
-                        the encryption was fine (signature is handled separately and
-                        returned as `signatures`) */
-                        if iterations == 0 && 0 == has_unencrypted_parts {
-                            self.encrypted = true;
+                        Err(err) => {
+                            bail!("failed to decrypt: {}", err);
                         }
                     }
-                    /* check for Autocrypt-Gossip */
                     if !gossip_headers.is_null() {
                         self.gossipped_addr = update_gossip_peerstates(
                             context,
@@ -414,10 +400,10 @@ impl E2eeHelper {
                 }
             }
         }
-        //mailmime_print(in_out_message);
         if !gossip_headers.is_null() {
             mailimf_fields_free(gossip_headers);
         }
+        Ok(())
     }
 }
 
@@ -484,7 +470,7 @@ fn load_or_generate_self_public_key(context: &Context, self_addr: impl AsRef<str
                 &public_key,
                 &private_key,
                 &self_addr,
-                1,
+                true,
                 &context.sql,
             ) {
                 true => {
@@ -508,6 +494,7 @@ unsafe fn update_gossip_peerstates(
     imffields: *mut mailimf_fields,
     gossip_headers: *const mailimf_fields,
 ) -> 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();
 
@@ -535,10 +522,10 @@ unsafe 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 {
@@ -563,209 +550,140 @@ unsafe fn update_gossip_peerstates(
     gossipped_addr
 }
 
-unsafe fn decrypt_recursive(
+fn decrypt_if_autocrypt_message(
     context: &Context,
-    mime: *mut Mailmime,
+    mime_undetermined: *mut Mailmime,
     private_keyring: &Keyring,
     public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
     ret_gossip_headers: *mut *mut mailimf_fields,
-    ret_has_unencrypted_parts: *mut libc::c_int,
-) -> Result<()> {
-    ensure!(!mime.is_null(), "Invalid mime reference");
-    let ct: *mut mailmime_content;
+) -> Result<(bool)> {
+    /* The returned bool is true if we detected an Autocrypt-encrypted
+    message and successfully decrypted it. Decryption then modifies the
+    passed in mime structure in place. The returned bool is false
+    if it was not an Autocrypt message.
 
-    if (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int {
-        ct = (*mime).mm_content_type;
-        if !ct.is_null()
-            && !(*ct).ct_subtype.is_null()
-            && strcmp(
-                (*ct).ct_subtype,
-                b"encrypted\x00" as *const u8 as *const libc::c_char,
-            ) == 0i32
-        {
-            for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
-                let mut decrypted_mime: *mut Mailmime = ptr::null_mut();
-                if decrypt_part(
-                    context,
-                    cur_data as *mut Mailmime,
-                    private_keyring,
-                    public_keyring_for_validate,
-                    ret_valid_signatures,
-                    &mut decrypted_mime,
-                ) {
-                    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(
-                            (*decrypted_mime).mm_mime_start,
-                            (*decrypted_mime).mm_length,
-                            &mut dummy,
-                            &mut test,
-                        ) == MAILIMF_NO_ERROR as libc::c_int
-                            && !test.is_null()
-                        {
-                            *ret_gossip_headers = test
-                        }
-                    }
-                    mailmime_substitute(mime, decrypted_mime);
-                    mailmime_free(mime);
-                    return Ok(());
-                }
-            }
-            *ret_has_unencrypted_parts = 1i32
-        } else {
-            for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
-                if decrypt_recursive(
-                    context,
-                    cur_data as *mut Mailmime,
-                    private_keyring,
-                    public_keyring_for_validate,
-                    ret_valid_signatures,
-                    ret_gossip_headers,
-                    ret_has_unencrypted_parts,
-                )
-                .is_ok()
-                {
-                    return Ok(());
-                }
-            }
+    Errors are returned for failures related to decryption of AC-messages.
+    */
+    ensure!(!mime_undetermined.is_null(), "Invalid mime reference");
+
+    let (mime, encrypted_data_part) = match wrapmime::get_autocrypt_mime(mime_undetermined) {
+        Err(_) => {
+            // not a proper autocrypt message, abort and ignore
+            return Ok(false);
         }
-    } else if (*mime).mm_type == MAILMIME_MESSAGE as libc::c_int {
-        if decrypt_recursive(
-            context,
-            (*mime).mm_data.mm_message.mm_msg_mime,
-            private_keyring,
-            public_keyring_for_validate,
-            ret_valid_signatures,
-            ret_gossip_headers,
-            ret_has_unencrypted_parts,
-        )
-        .is_ok()
-        {
-            return Ok(());
-        }
-    } else {
-        *ret_has_unencrypted_parts = 1;
+        Ok(res) => res,
+    };
+
+    let decrypted_mime = decrypt_part(
+        context,
+        encrypted_data_part,
+        private_keyring,
+        public_keyring_for_validate,
+        ret_valid_signatures,
+    )?;
+    /* decrypted_mime is a dangling pointer which we now put into
+    mailmime's Ownership */
+    unsafe {
+        mailmime_substitute(mime, decrypted_mime);
+        mailmime_free(mime);
     }
 
-    Err(format_err!("Failed to decrypt"))
+    /* 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;
+            let mut test: *mut mailimf_fields = ptr::null_mut();
+            if mailimf_envelope_and_optional_fields_parse(
+                (*decrypted_mime).mm_mime_start,
+                (*decrypted_mime).mm_length,
+                &mut dummy,
+                &mut test,
+            ) == MAILIMF_NO_ERROR as libc::c_int
+                && !test.is_null()
+            {
+                *ret_gossip_headers = test
+            }
+        }
+    }
+    return Ok(true);
 }
 
-unsafe fn decrypt_part(
+fn decrypt_part(
     _context: &Context,
     mime: *mut Mailmime,
     private_keyring: &Keyring,
     public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
-    ret_decrypted_mime: *mut *mut Mailmime,
-) -> bool {
-    let mut ok_to_continue = true;
+) -> Result<*mut Mailmime> {
     let mime_data: *mut mailmime_data;
-    let mut mime_transfer_encoding: libc::c_int = MAILMIME_MECHANISM_BINARY as libc::c_int;
-    /* mmap_string_unref()'d if set */
-    let mut transfer_decoding_buffer: *mut libc::c_char = ptr::null_mut();
-    /* must not be free()'d */
-    let mut decoded_data: *const libc::c_char = ptr::null_mut();
-    let mut decoded_data_bytes: libc::size_t = 0;
-    let mut sth_decrypted = false;
+    let mut mime_transfer_encoding = MAILMIME_MECHANISM_BINARY as libc::c_int;
 
-    *ret_decrypted_mime = ptr::null_mut();
-    mime_data = (*mime).mm_data.mm_single;
-    /* MAILMIME_DATA_FILE indicates, the data is in a file; AFAIK this is not used on parsing */
-    if !((*mime_data).dt_type != MAILMIME_DATA_TEXT as libc::c_int
-        || (*mime_data).dt_data.dt_text.dt_data.is_null()
-        || (*mime_data).dt_data.dt_text.dt_length <= 0)
-    {
-        if !(*mime).mm_mime_fields.is_null() {
-            for cur_data in (*(*(*mime).mm_mime_fields).fld_list).into_iter() {
-                let field: *mut mailmime_field = cur_data as *mut _;
-                if (*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
+    unsafe {
+        mime_data = (*mime).mm_data.mm_single;
+    }
+    if !wrapmime::has_decryptable_data(mime_data) {
+        return Ok(ptr::null_mut());
+    }
+
+    if let Some(enc) = wrapmime::get_mime_transfer_encoding(mime) {
+        mime_transfer_encoding = enc;
+    }
+
+    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();
+
+    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(
+                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
                 }
-            }
-        }
-        /* regard `Content-Transfer-Encoding:` */
-        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
-        {
-            decoded_data = (*mime_data).dt_data.dt_text.dt_data;
-            decoded_data_bytes = (*mime_data).dt_data.dt_text.dt_length;
-            if decoded_data.is_null() || decoded_data_bytes <= 0 {
-                /* no error - but no data */
-                ok_to_continue = false;
-            }
-        } else {
-            let r: libc::c_int;
-            let mut current_index: libc::size_t = 0;
-            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
+                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: 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()
             {
-                ok_to_continue = false;
-            } else {
-                decoded_data = transfer_decoding_buffer;
-            }
-        }
-        if ok_to_continue {
-            /* encrypted, decoded data in decoded_data now ... */
-            if has_decrypted_pgp_armor(decoded_data, decoded_data_bytes as libc::c_int) {
-                let add_signatures = if ret_valid_signatures.is_empty() {
-                    Some(ret_valid_signatures)
-                } else {
-                    None
-                };
-
-                /*if we already have fingerprints, do not add more; this ensures, only the fingerprints from the outer-most part are collected */
-                if let Ok(plain) = dc_pgp_pk_decrypt(
-                    std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes),
-                    &private_keyring,
-                    &public_keyring_for_validate,
-                    add_signatures,
-                ) {
-                    let plain_bytes = plain.len();
-                    let plain_buf = plain.as_ptr() as *const libc::c_char;
-
-                    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() {
-                            mailmime_free(decrypted_mime);
-                        }
-                    } else {
-                        *ret_decrypted_mime = decrypted_mime;
-                        sth_decrypted = true;
-                    }
-                    std::mem::forget(plain);
+                if !decrypted_mime.is_null() {
+                    mailmime_free(decrypted_mime);
                 }
+            } else {
+                ret_decrypted_mime = decrypted_mime;
             }
+            std::mem::forget(plain);
         }
+        mmap_string_unref(decoded_data);
     }
-    //mailmime_substitute(mime, new_mime);
-    //s. mailprivacy_gnupg.c::pgp_decrypt()
-    if !transfer_decoding_buffer.is_null() {
-        mmap_string_unref(transfer_decoding_buffer);
-    }
-
-    sth_decrypted
+    Ok(ret_decrypted_mime)
 }
 
 unsafe fn has_decrypted_pgp_armor(str__: *const libc::c_char, mut str_bytes: libc::c_int) -> bool {
@@ -847,6 +765,7 @@ pub fn ensure_secret_key_exists(context: &Context) -> Result<String> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use libc::free;
 
     use crate::test_utils::*;
 

src/error.rs

@@ -26,6 +26,10 @@ pub enum Error {
     CStringError(crate::dc_tools::CStringError),
     #[fail(display = "PGP: {:?}", _0)]
     Pgp(pgp::errors::Error),
+    #[fail(display = "Base64Decode: {:?}", _0)]
+    Base64Decode(base64::DecodeError),
+    #[fail(display = "{:?}", _0)]
+    FromUtf8(std::string::FromUtf8Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -36,6 +40,12 @@ impl From<rusqlite::Error> for Error {
     }
 }
 
+impl From<base64::DecodeError> for Error {
+    fn from(err: base64::DecodeError) -> Error {
+        Error::Base64Decode(err)
+    }
+}
+
 impl From<failure::Error> for Error {
     fn from(err: failure::Error) -> Error {
         Error::Failure(err)
@@ -60,6 +70,12 @@ impl From<std::str::Utf8Error> for Error {
     }
 }
 
+impl From<std::string::FromUtf8Error> for Error {
+    fn from(err: std::string::FromUtf8Error) -> Error {
+        Error::FromUtf8(err)
+    }
+}
+
 impl From<image_meta::ImageError> for Error {
     fn from(err: image_meta::ImageError) -> Error {
         Error::Image(err)

src/events.rs

@@ -167,7 +167,7 @@ pub enum Event {
     #[strum(props(id = "2041"))]
     ConfigureProgress(usize),
 
-    /// Inform about the import/export progress started by dc_imex().
+    /// Inform about the import/export progress started by imex().
     ///
     /// @param data1 (usize) 0=error, 1-999=progress in permille, 1000=success and done
     /// @param data2 0
@@ -175,8 +175,8 @@ pub enum Event {
     #[strum(props(id = "2051"))]
     ImexProgress(usize),
 
-    /// A file has been exported. A file has been written by dc_imex().
-    /// This event may be sent multiple times by a single call to dc_imex().
+    /// A file has been exported. A file has been written by imex().
+    /// This event may be sent multiple times by a single call to imex().
     ///
     /// A typical purpose for a handler of this event may be to make the file public to some system
     /// services.

src/imap.rs

@@ -110,6 +110,8 @@ impl Client {
     ) -> imap::error::Result<Self> {
         let stream = net::TcpStream::connect(addr)?;
         let tls = native_tls::TlsConnector::builder()
+            // see also: https://github.com/deltachat/deltachat-core-rust/issues/203
+            .danger_accept_invalid_certs(true)
             .danger_accept_invalid_hostnames(true)
             .build()
             .unwrap();
@@ -953,14 +955,7 @@ impl Imap {
             if !is_deleted && msg.body().is_some() {
                 let body = msg.body().unwrap();
                 unsafe {
-                    dc_receive_imf(
-                        context,
-                        body.as_ptr() as *const libc::c_char,
-                        body.len(),
-                        folder.as_ref(),
-                        server_uid,
-                        flags as u32,
-                    );
+                    dc_receive_imf(context, &body, folder.as_ref(), server_uid, flags as u32);
                 }
             }
         }

src/imex.rs

@@ -2,10 +2,7 @@ use std::ffi::CString;
 use std::path::Path;
 use std::ptr;
 
-use libc::{free, strlen};
-use mmime::mailmime::content::*;
-use mmime::mmapstring::*;
-use mmime::other::*;
+use num_traits::FromPrimitive;
 use rand::{thread_rng, Rng};
 
 use crate::chat;
@@ -25,12 +22,48 @@ use crate::pgp::*;
 use crate::sql::{self, Sql};
 use crate::stock::StockMessage;
 
-// import/export and tools
-// param1 is a directory where the keys are written to
-// param1 is a directory where the keys are searched in and read from
-// param1 is a directory where the backup is written to
-// param1 is the file with the backup to import
-pub fn dc_imex(context: &Context, what: libc::c_int, param1: Option<impl AsRef<Path>>) {
+#[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+#[repr(i32)]
+pub enum ImexMode {
+    /// Export all private keys and all public keys of the user to the
+    /// directory given as `param1`.  The default key is written to the files `public-key-default.asc`
+    /// and `private-key-default.asc`, if there are more keys, they are written to files as
+    /// `public-key-<id>.asc` and `private-key-<id>.asc`
+    ExportSelfKeys = 1,
+    /// Import private keys found in the directory given as `param1`.
+    /// The last imported key is made the default keys unless its name contains the string `legacy`.
+    /// Public keys are not imported.
+    ImportSelfKeys = 2,
+    /// Export a backup to the directory given as `param1`.
+    /// The backup contains all contacts, chats, images and other data and device independent settings.
+    /// The backup does not contain device dependent settings as ringtones or LED notification settings.
+    /// The name of the backup is typically `delta-chat.<day>.bak`, if more than one backup is create on a day,
+    /// the format is `delta-chat.<day>-<number>.bak`
+    ExportBackup = 11,
+    /// `param1` is the file (not: directory) to import. The file is normally
+    /// created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
+    /// is only possible as long as the context is not configured or used in another way.
+    ImportBackup = 12,
+}
+
+/// Import/export things.
+/// For this purpose, the function creates a job that is executed in the IMAP-thread then;
+/// this requires to call dc_perform_imap_jobs() regularly.
+///
+/// What to do is defined by the _what_ parameter.
+///
+/// While dc_imex() returns immediately, the started job may take a while,
+/// you can stop it using dc_stop_ongoing_process(). During execution of the job,
+/// some events are sent out:
+///
+/// - A number of #DC_EVENT_IMEX_PROGRESS events are sent and may be used to create
+///   a progress bar or stuff like that. Moreover, you'll be informed when the imex-job is done.
+///
+/// - For each file written on export, the function sends #DC_EVENT_IMEX_FILE_WRITTEN
+///
+/// Only one import-/export-progress can run at the same time.
+/// To cancel an import-/export-progress, use dc_stop_ongoing_process().
+pub fn imex(context: &Context, what: ImexMode, param1: Option<impl AsRef<Path>>) {
     let mut param = Params::new();
     param.set_int(Param::Cmd, what as i32);
     if let Some(param1) = param1 {
@@ -42,7 +75,7 @@ pub fn dc_imex(context: &Context, what: libc::c_int, param1: Option<impl AsRef<P
 }
 
 /// Returns the filename of the backup if found, nullptr otherwise.
-pub fn dc_imex_has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<String> {
+pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<String> {
     let dir_name = dir_name.as_ref();
     let dir_iter = std::fs::read_dir(dir_name)?;
     let mut newest_backup_time = 0;
@@ -75,12 +108,10 @@ pub fn dc_imex_has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Resu
     }
 }
 
-pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
+pub fn initiate_key_transfer(context: &Context) -> Result<String> {
     let mut msg: Message;
-    if !dc_alloc_ongoing(context) {
-        return std::ptr::null_mut();
-    }
-    let setup_code = dc_create_setup_code(context);
+    ensure!(dc_alloc_ongoing(context), "could not allocate ongoing");
+    let setup_code = create_setup_code(context);
     /* this may require a keypair to be created. this may take a second ... */
     if !context
         .running_state
@@ -89,7 +120,7 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
         .unwrap()
         .shall_stop_ongoing
     {
-        if let Ok(ref setup_file_content) = dc_render_setup_file(context, &setup_code) {
+        if let Ok(ref setup_file_content) = render_setup_file(context, &setup_code) {
             /* encrypting may also take a while ... */
             if !context
                 .running_state
@@ -149,13 +180,13 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
     }
     dc_free_ongoing(context);
 
-    setup_code.strdup()
+    Ok(setup_code)
 }
 
 /// Renders HTML body of a setup file message.
 ///
 /// The `passphrase` must be at least 2 characters long.
-pub fn dc_render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
+pub fn render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
     ensure!(
         passphrase.len() >= 2,
         "Passphrase must be at least 2 chars long."
@@ -205,7 +236,7 @@ pub fn dc_render_setup_file(context: &Context, passphrase: &str) -> Result<Strin
     ))
 }
 
-pub fn dc_create_setup_code(_context: &Context) -> String {
+pub fn create_setup_code(_context: &Context) -> String {
     let mut random_val: u16;
     let mut rng = thread_rng();
     let mut ret = String::new();
@@ -213,22 +244,22 @@ pub fn dc_create_setup_code(_context: &Context) -> String {
     for i in 0..9 {
         loop {
             random_val = rng.gen();
-            if !(random_val as libc::c_int > 60000) {
+            if !(random_val as usize > 60000) {
                 break;
             }
         }
-        random_val = (random_val as libc::c_int % 10000) as u16;
+        random_val = (random_val as usize % 10000) as u16;
         ret += &format!(
             "{}{:04}",
             if 0 != i { "-" } else { "" },
-            random_val as libc::c_int,
+            random_val as usize
         );
     }
 
     ret
 }
 
-pub fn dc_continue_key_transfer(context: &Context, msg_id: u32, setup_code: &str) -> Result<()> {
+pub fn continue_key_transfer(context: &Context, msg_id: u32, setup_code: &str) -> Result<()> {
     ensure!(msg_id > DC_MSG_ID_LAST_SPECIAL, "wrong id");
 
     let msg = Message::load_from_db(context, msg_id);
@@ -242,16 +273,14 @@ pub fn dc_continue_key_transfer(context: &Context, msg_id: u32, setup_code: &str
     );
 
     if let Some(filename) = msg.get_file(context) {
-        if let Ok(buf) = dc_read_file(context, filename) {
-            let norm_sc = CString::yolo(dc_normalize_setup_code(setup_code));
-            let armored_key: String;
-            unsafe {
-                let sc = dc_decrypt_setup_file(context, norm_sc.as_ptr(), buf.as_ptr().cast());
-                ensure!(!sc.is_null(), "bad setup code");
-                armored_key = to_string(sc);
-                free(sc as *mut libc::c_void);
+        if let Ok(ref mut buf) = dc_read_file(context, filename) {
+            let sc = normalize_setup_code(setup_code);
+            if let Ok(armored_key) = decrypt_setup_file(context, sc, buf) {
+                set_self_key(context, &armored_key, true, true)?;
+            } else {
+                bail!("Bad setup code.")
             }
-            set_self_key(context, &armored_key, true, true)?;
+
             Ok(())
         } else {
             bail!("Cannot read Autocrypt Setup Message file.");
@@ -321,7 +350,7 @@ fn set_self_key(
         &public_key,
         &private_key,
         self_addr.unwrap(),
-        set_default as libc::c_int,
+        set_default,
         &context.sql,
     ) {
         bail!("Cannot save keypair, internal key-state possibly corrupted now!");
@@ -329,66 +358,56 @@ fn set_self_key(
     Ok(())
 }
 
-pub unsafe fn dc_decrypt_setup_file(
-    context: &Context,
-    passphrase: *const libc::c_char,
-    filecontent: *const libc::c_char,
-) -> *mut libc::c_char {
-    let fc_buf: *mut libc::c_char;
+fn decrypt_setup_file(
+    _context: &Context,
+    passphrase: impl AsRef<str>,
+    filecontent: &mut [u8],
+) -> Result<String> {
     let mut fc_headerline = String::default();
     let mut fc_base64: *const libc::c_char = ptr::null();
-    let mut binary: *mut libc::c_char = ptr::null_mut();
-    let mut binary_bytes: libc::size_t = 0;
-    let mut indx: libc::size_t = 0;
 
-    let mut payload: *mut libc::c_char = ptr::null_mut();
-    fc_buf = dc_strdup(filecontent);
-    if dc_split_armored_data(
-        fc_buf,
-        &mut fc_headerline,
-        ptr::null_mut(),
-        ptr::null_mut(),
-        &mut fc_base64,
-    ) && fc_headerline == "-----BEGIN PGP MESSAGE-----"
-        && !fc_base64.is_null()
-    {
-        /* convert base64 to binary */
-        /*must be freed using mmap_string_unref()*/
-        if !(mailmime_base64_body_parse(
-            fc_base64,
-            strlen(fc_base64),
-            &mut indx,
-            &mut binary,
-            &mut binary_bytes,
-        ) != MAILIMF_NO_ERROR as libc::c_int
-            || binary.is_null()
-            || binary_bytes == 0)
-        {
-            /* decrypt symmetrically */
-            match dc_pgp_symm_decrypt(
-                as_str(passphrase),
-                std::slice::from_raw_parts(binary as *const u8, binary_bytes),
-            ) {
-                Ok(plain) => {
-                    let payload_c = CString::new(plain).unwrap();
-                    payload = strdup(payload_c.as_ptr());
-                }
-                Err(err) => {
-                    error!(context, "Failed to decrypt message: {:?}", err);
-                }
-            }
-        }
+    let split_result = unsafe {
+        dc_split_armored_data(
+            filecontent.as_mut_ptr().cast(),
+            &mut fc_headerline,
+            ptr::null_mut(),
+            ptr::null_mut(),
+            &mut fc_base64,
+        )
+    };
+
+    if !split_result || fc_headerline != "-----BEGIN PGP MESSAGE-----" || fc_base64.is_null() {
+        bail!("Invalid armored data");
     }
 
-    free(fc_buf as *mut libc::c_void);
-    if !binary.is_null() {
-        mmap_string_unref(binary);
-    }
+    // convert base64 to binary
+    let base64_encoded =
+        unsafe { std::slice::from_raw_parts(fc_base64 as *const u8, libc::strlen(fc_base64)) };
 
-    payload
+    let data = base64_decode(&base64_encoded)?;
+
+    // decrypt symmetrically
+    let payload = dc_pgp_symm_decrypt(passphrase.as_ref(), &data)?;
+    let payload_str = String::from_utf8(payload)?;
+
+    Ok(payload_str)
 }
 
-pub fn dc_normalize_setup_code(s: &str) -> String {
+/// Decode the base64 encoded slice. Handles line breaks.
+fn base64_decode(input: &[u8]) -> Result<Vec<u8>> {
+    use std::io::Read;
+    let c = std::io::Cursor::new(input);
+    let lr = pgp::line_reader::LineReader::new(c);
+    let br = pgp::base64_reader::Base64Reader::new(lr);
+    let mut reader = pgp::base64_decoder::Base64Decoder::new(br);
+
+    let mut data = Vec::new();
+    reader.read_to_end(&mut data)?;
+
+    Ok(data)
+}
+
+pub fn normalize_setup_code(s: &str) -> String {
     let mut out = String::new();
     for c in s.chars() {
         if c >= '0' && c <= '9' {
@@ -402,9 +421,9 @@ pub fn dc_normalize_setup_code(s: &str) -> String {
 }
 
 #[allow(non_snake_case)]
-pub fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
+pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     ensure!(dc_alloc_ongoing(context), "could not allocate ongoing");
-    let what = job.param.get_int(Param::Cmd).unwrap_or_default();
+    let what: Option<ImexMode> = job.param.get_int(Param::Cmd).and_then(ImexMode::from_i32);
     let param = job.param.get(Param::Arg).unwrap_or_default();
 
     ensure!(!param.is_empty(), "No Import/export dir/file given.");
@@ -412,8 +431,8 @@ pub fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     context.call_cb(Event::ImexProgress(10));
 
     ensure!(context.sql.is_open(), "Database not opened.");
-    if what == DC_IMEX_EXPORT_BACKUP || what == DC_IMEX_EXPORT_SELF_KEYS {
-        /* before we export anything, make sure the private key exists */
+    if what == Some(ImexMode::ExportBackup) || what == Some(ImexMode::ExportSelfKeys) {
+        // before we export anything, make sure the private key exists
         if e2ee::ensure_secret_key_exists(context).is_err() {
             dc_free_ongoing(context);
             bail!("Cannot create private key or private key not available.");
@@ -423,12 +442,12 @@ pub fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     }
     let path = Path::new(param);
     let success = match what {
-        DC_IMEX_EXPORT_SELF_KEYS => export_self_keys(context, path),
-        DC_IMEX_IMPORT_SELF_KEYS => import_self_keys(context, path),
-        DC_IMEX_EXPORT_BACKUP => unsafe { export_backup(context, path) },
-        DC_IMEX_IMPORT_BACKUP => import_backup(context, path),
-        _ => {
-            bail!("unknown IMEX type: {}", what);
+        Some(ImexMode::ExportSelfKeys) => export_self_keys(context, path),
+        Some(ImexMode::ImportSelfKeys) => import_self_keys(context, path),
+        Some(ImexMode::ExportBackup) => export_backup(context, path),
+        Some(ImexMode::ImportBackup) => import_backup(context, path),
+        None => {
+            bail!("unknown IMEX type");
         }
     };
     dc_free_ongoing(context);
@@ -445,11 +464,7 @@ pub fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     }
 }
 
-/*******************************************************************************
- * Import backup
- ******************************************************************************/
-
-#[allow(non_snake_case)]
+/// Import Backup
 fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Result<()> {
     info!(
         context,
@@ -525,13 +540,13 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
                     continue;
                 }
 
-                let pathNfilename = context.get_blobdir().join(file_name);
-                if dc_write_file(context, &pathNfilename, &file_blob) {
+                let path_filename = context.get_blobdir().join(file_name);
+                if dc_write_file(context, &path_filename, &file_blob) {
                     continue;
                 }
                 bail!(
                     "Storage full? Cannot write file {} with {} bytes.",
-                    pathNfilename.display(),
+                    path_filename.display(),
                     file_blob.len(),
                 );
             }
@@ -552,9 +567,8 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
  ******************************************************************************/
 /* the FILE_PROGRESS macro calls the callback with the permille of files processed.
 The macro avoids weird values of 0% or 100% while still working. */
-#[allow(non_snake_case)]
-unsafe fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
-    let mut ok_to_continue: bool;
+fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
+    let mut ok_to_continue = true;
     let mut success = false;
 
     let mut delete_dest_file: libc::c_int = 0;
@@ -571,54 +585,55 @@ unsafe fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()>
 
     sql::try_execute(context, &context.sql, "VACUUM;").ok();
     context.sql.close(context);
-    let mut closed = true;
     info!(
         context,
         "Backup \"{}\" to \"{}\".",
         context.get_dbfile().display(),
         dest_path_filename.display(),
     );
-    if dc_copy_file(context, context.get_dbfile(), &dest_path_filename) {
-        context.sql.open(&context, &context.get_dbfile(), 0);
-        closed = false;
-        /* add all files as blobs to the database copy (this does not require the source to be locked, neigher the destination as it is used only here) */
-        /*for logging only*/
-        let sql = Sql::new();
-        if sql.open(context, &dest_path_filename, 0) {
-            if !sql.table_exists("backup_blobs") {
-                if sql::execute(
-                    context,
-                    &sql,
-                    "CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);",
-                    params![],
-                )
-                .is_err()
-                {
-                    /* error already logged */
-                    ok_to_continue = false;
-                } else {
-                    ok_to_continue = true;
-                }
-            } else {
-                ok_to_continue = true;
+    let copied = dc_copy_file(context, context.get_dbfile(), &dest_path_filename);
+    context.sql.open(&context, &context.get_dbfile(), 0);
+    if !copied {
+        let s = dest_path_filename.to_string_lossy().to_string();
+        bail!(
+            "could not copy file from {:?} to {:?}",
+            context.get_dbfile(),
+            s
+        );
+    }
+    /* add all files as blobs to the database copy (this does not require the source to be locked, neigher the destination as it is used only here) */
+    /*for logging only*/
+    let sql = Sql::new();
+    if sql.open(context, &dest_path_filename, 0) {
+        if !sql.table_exists("backup_blobs") {
+            if sql::execute(
+                context,
+                &sql,
+                "CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);",
+                params![],
+            )
+            .is_err()
+            {
+                /* error already logged */
+                ok_to_continue = false;
             }
-            if ok_to_continue {
-                let mut total_files_cnt = 0;
-                let dir = context.get_blobdir();
-                if let Ok(dir_handle) = std::fs::read_dir(&dir) {
-                    total_files_cnt += dir_handle.filter(|r| r.is_ok()).count();
+        }
+        if ok_to_continue {
+            let mut total_files_cnt = 0;
+            let dir = context.get_blobdir();
+            if let Ok(dir_handle) = std::fs::read_dir(&dir) {
+                total_files_cnt += dir_handle.filter(|r| r.is_ok()).count();
 
-                    info!(context, "EXPORT: total_files_cnt={}", total_files_cnt);
-                    if total_files_cnt > 0 {
-                        // scan directory, pass 2: copy files
-                        if let Ok(dir_handle) = std::fs::read_dir(&dir) {
-                            sql.prepare(
+                info!(context, "EXPORT: total_files_cnt={}", total_files_cnt);
+                if total_files_cnt > 0 {
+                    // scan directory, pass 2: copy files
+                    if let Ok(dir_handle) = std::fs::read_dir(&dir) {
+                        sql.prepare(
                                     "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
                                     move |mut stmt, _| {
                                         let mut processed_files_cnt = 0;
                                         for entry in dir_handle {
                                             if entry.is_err() {
-                                                ok_to_continue = true;
                                                 break;
                                             }
                                             let entry = entry.unwrap();
@@ -651,9 +666,9 @@ unsafe fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()>
                                                     continue;
                                                 } else {
                                                     info!(context, "EXPORTing filename={}", name);
-                                                    let curr_pathNfilename = context.get_blobdir().join(entry.file_name());
+                                                    let curr_path_filename = context.get_blobdir().join(entry.file_name());
                                                     if let Ok(buf) =
-                                                        dc_read_file(context, &curr_pathNfilename)
+                                                        dc_read_file(context, &curr_path_filename)
                                                     {
                                                         if buf.is_empty() {
                                                             continue;
@@ -662,7 +677,7 @@ unsafe fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()>
                                                             error!(
                                                                 context,
                                                                 "Disk full? Cannot add file \"{}\" to backup.",
-                                                                curr_pathNfilename.display(),
+                                                                curr_path_filename.display(),
                                                             );
                                                             /* this is not recoverable! writing to the sqlite database should work! */
                                                             ok_to_continue = false;
@@ -677,39 +692,34 @@ unsafe fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()>
                                         Ok(())
                                     }
                                 ).unwrap();
-                        } else {
-                            error!(
-                                context,
-                                "Backup: Cannot copy from blob-directory \"{}\".",
-                                context.get_blobdir().display(),
-                            );
-                        }
                     } else {
-                        info!(context, "Backup: No files to copy.",);
-                        ok_to_continue = true;
-                    }
-                    if ok_to_continue {
-                        if sql
-                            .set_config_int(context, "backup_time", now as i32)
-                            .is_ok()
-                        {
-                            context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
-                            success = true;
-                        }
+                        error!(
+                            context,
+                            "Backup: Cannot copy from blob-directory \"{}\".",
+                            context.get_blobdir().display(),
+                        );
                     }
                 } else {
-                    error!(
-                        context,
-                        "Backup: Cannot get info for blob-directory \"{}\".",
-                        context.get_blobdir().display(),
-                    );
-                };
-            }
+                    info!(context, "Backup: No files to copy.",);
+                }
+                if ok_to_continue {
+                    if sql
+                        .set_config_int(context, "backup_time", now as i32)
+                        .is_ok()
+                    {
+                        context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
+                        success = true;
+                    }
+                }
+            } else {
+                error!(
+                    context,
+                    "Backup: Cannot get info for blob-directory \"{}\".",
+                    context.get_blobdir().display(),
+                );
+            };
         }
     }
-    if closed {
-        context.sql.open(&context, &context.get_dbfile(), 0);
-    }
     if 0 != delete_dest_file {
         dc_delete_file(context, &dest_path_filename);
     }
@@ -779,7 +789,7 @@ fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
                     ptr::null_mut(),
                     ptr::null_mut(),
                 );
-                free(buf2 as *mut libc::c_void);
+                libc::free(buf2 as *mut libc::c_void);
             }
             if split_res
                 && buf2_headerline.contains("-----BEGIN PGP PUBLIC KEY BLOCK-----")
@@ -890,7 +900,7 @@ mod tests {
         let t = test_context(Some(Box::new(logging_cb)));
 
         configure_alice_keypair(&t.ctx);
-        let msg = dc_render_setup_file(&t.ctx, "hello").unwrap();
+        let msg = render_setup_file(&t.ctx, "hello").unwrap();
         println!("{}", &msg);
         // Check some substrings, indicating things got substituted.
         // In particular note the mixing of `\r\n` and `\n` depending
@@ -916,10 +926,10 @@ mod tests {
     }
 
     #[test]
-    fn test_render_setup_file_newline_replace() {
+    fn otest_render_setup_file_newline_replace() {
         let t = test_context(Some(Box::new(ac_setup_msg_cb)));
         configure_alice_keypair(&t.ctx);
-        let msg = dc_render_setup_file(&t.ctx, "pw").unwrap();
+        let msg = render_setup_file(&t.ctx, "pw").unwrap();
         println!("{}", &msg);
         assert!(msg.contains("<p>hello<br>there</p>"));
     }
@@ -927,7 +937,7 @@ mod tests {
     #[test]
     fn test_create_setup_code() {
         let t = dummy_context();
-        let setupcode = dc_create_setup_code(&t.ctx);
+        let setupcode = create_setup_code(&t.ctx);
         assert_eq!(setupcode.len(), 44);
         assert_eq!(setupcode.chars().nth(4).unwrap(), '-');
         assert_eq!(setupcode.chars().nth(9).unwrap(), '-');
@@ -955,12 +965,65 @@ mod tests {
 
     #[test]
     fn test_normalize_setup_code() {
-        let norm = dc_normalize_setup_code("123422343234423452346234723482349234");
+        let norm = normalize_setup_code("123422343234423452346234723482349234");
         assert_eq!(norm, "1234-2234-3234-4234-5234-6234-7234-8234-9234");
 
-        let norm = dc_normalize_setup_code(
-            "\t1 2 3422343234- foo bar-- 423-45 2 34 6234723482349234      ",
-        );
+        let norm =
+            normalize_setup_code("\t1 2 3422343234- foo bar-- 423-45 2 34 6234723482349234      ");
         assert_eq!(norm, "1234-2234-3234-4234-5234-6234-7234-8234-9234");
     }
+
+    /* S_EM_SETUPFILE is a AES-256 symm. encrypted setup message created by Enigmail
+    with an "encrypted session key", see RFC 4880.  The code is in S_EM_SETUPCODE */
+    const S_EM_SETUPCODE: &str = "1742-0185-6197-1303-7016-8412-3581-4441-0597";
+    const S_EM_SETUPFILE: &str = include_str!("../test-data/message/stress.txt");
+
+    #[test]
+    fn test_split_and_decrypt() {
+        let ctx = dummy_context();
+        let context = &ctx.ctx;
+
+        let mut headerline = String::default();
+        let mut setupcodebegin = ptr::null();
+        let mut preferencrypt = ptr::null();
+
+        let mut buf_1 = S_EM_SETUPFILE.to_string();
+
+        unsafe {
+            assert!(dc_split_armored_data(
+                buf_1.as_mut_ptr().cast(),
+                &mut headerline,
+                &mut setupcodebegin,
+                &mut preferencrypt,
+                ptr::null_mut(),
+            ));
+        }
+        assert_eq!(headerline, "-----BEGIN PGP MESSAGE-----");
+        assert!(!setupcodebegin.is_null());
+
+        // TODO: verify that this is the right check
+        assert!(S_EM_SETUPCODE.starts_with(as_str(setupcodebegin)));
+
+        assert!(preferencrypt.is_null());
+
+        let mut setup_file = S_EM_SETUPFILE.to_string();
+        let mut decrypted = unsafe {
+            decrypt_setup_file(context, S_EM_SETUPCODE, setup_file.as_bytes_mut()).unwrap()
+        };
+
+        unsafe {
+            assert!(dc_split_armored_data(
+                decrypted.as_mut_ptr().cast(),
+                &mut headerline,
+                &mut setupcodebegin,
+                &mut preferencrypt,
+                ptr::null_mut(),
+            ));
+        }
+
+        assert_eq!(headerline, "-----BEGIN PGP PRIVATE KEY BLOCK-----");
+        assert!(setupcodebegin.is_null());
+        assert!(!preferencrypt.is_null());
+        assert_eq!(as_str(preferencrypt), "mutual",);
+    }
 }

src/job.rs

@@ -7,10 +7,10 @@ use crate::chat;
 use crate::configure::*;
 use crate::constants::*;
 use crate::context::Context;
-use crate::dc_imex::*;
 use crate::dc_tools::*;
 use crate::events::Event;
 use crate::imap::*;
+use crate::imex::*;
 use crate::location;
 use crate::login_param::LoginParam;
 use crate::message::{self, Message, MessageState};
@@ -824,7 +824,7 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
                 Action::MoveMsg => job.do_DC_JOB_MOVE_MSG(context),
                 Action::SendMdn => job.do_DC_JOB_SEND(context),
                 Action::ConfigureImap => unsafe { dc_job_do_DC_JOB_CONFIGURE_IMAP(context) },
-                Action::ImexImap => match dc_job_do_DC_JOB_IMEX_IMAP(context, &job) {
+                Action::ImexImap => match job_do_DC_JOB_IMEX_IMAP(context, &job) {
                     Ok(()) => {}
                     Err(err) => {
                         error!(context, "{}", err);

src/key.rs

@@ -2,7 +2,6 @@ use std::collections::BTreeMap;
 use std::io::Cursor;
 use std::path::Path;
 
-use libc;
 use pgp::composed::{Deserializable, SignedPublicKey, SignedSecretKey};
 use pgp::ser::Serialize;
 use pgp::types::{KeyTrait, SecretKeyTrait};
@@ -254,14 +253,14 @@ pub fn dc_key_save_self_keypair(
     public_key: &Key,
     private_key: &Key,
     addr: impl AsRef<str>,
-    is_default: libc::c_int,
+    is_default: bool,
     sql: &Sql,
 ) -> bool {
     sql::execute(
         context,
         sql,
         "INSERT INTO keypairs (addr, is_default, public_key, private_key, created) VALUES (?,?,?,?,?);",
-        params![addr.as_ref(), is_default, public_key.to_bytes(), private_key.to_bytes(), time()],
+        params![addr.as_ref(), is_default as i32, public_key.to_bytes(), private_key.to_bytes(), time()],
     ).is_ok()
 }
 

src/lib.rs

@@ -39,36 +39,36 @@ pub mod contact;
 pub mod context;
 mod e2ee;
 mod imap;
+pub mod imex;
 pub mod job;
 mod job_thread;
 pub mod key;
 pub mod keyring;
 pub mod location;
+mod login_param;
 pub mod lot;
 pub mod message;
+mod mimefactory;
 pub mod oauth2;
 mod param;
 pub mod peerstate;
 pub mod pgp;
 pub mod qr;
+pub mod securejoin;
 mod smtp;
 pub mod sql;
 mod stock;
+mod token;
+#[macro_use]
+mod wrapmime;
 
 pub mod dc_array;
 mod dc_dehtml;
-pub mod dc_imex;
 pub mod dc_mimeparser;
 pub mod dc_receive_imf;
 mod dc_simplify;
 mod dc_strencode;
 pub mod dc_tools;
-mod login_param;
-mod mimefactory;
-pub mod securejoin;
-mod token;
-#[macro_use]
-mod wrapmime;
 
 #[cfg(test)]
 mod test_utils;

src/message.rs

@@ -2,7 +2,6 @@ use std::path::{Path, PathBuf};
 use std::ptr;
 
 use deltachat_derive::{FromSql, ToSql};
-use libc::free;
 
 use crate::chat::{self, Chat};
 use crate::constants::*;
@@ -108,18 +107,6 @@ impl Message {
             msg.hidden = row.get(18)?;
             msg.location_id = row.get(19)?;
             msg.chat_blocked = row.get::<_, Option<Blocked>>(20)?.unwrap_or_default();
-            if msg.chat_blocked == Blocked::Deaddrop {
-                if let Some(ref text) = msg.text {
-                    unsafe {
-                        let ptr = text.strdup();
-
-                        dc_truncate_n_unwrap_str(ptr, 256, 0);
-
-                        msg.text = Some(to_string(ptr));
-                        free(ptr.cast());
-                    }
-                }
-            };
             Ok(msg)
         })
     }

src/peerstate.rs

@@ -7,6 +7,7 @@ use crate::aheader::*;
 use crate::chat::*;
 use crate::constants::*;
 use crate::context::Context;
+use crate::error::*;
 use crate::key::*;
 use crate::sql::{self, Sql};
 
@@ -408,28 +409,19 @@ impl<'a> Peerstate<'a> {
         success
     }
 
-    pub fn save_to_db(&self, sql: &Sql, create: bool) -> bool {
-        let mut success = false;
-
-        if self.addr.is_none() {
-            return success;
-        }
-
+    pub fn save_to_db(&self, sql: &Sql, create: bool) -> Result<()> {
+        ensure!(!self.addr.is_none(), "self.addr is not configured");
         if create {
-            if sql::execute(
+            sql::execute(
                 self.context,
                 sql,
                 "INSERT INTO acpeerstates (addr) VALUES(?);",
                 params![self.addr.as_ref().unwrap()],
-            )
-            .is_err()
-            {
-                return false;
-            }
+            )?;
         }
 
         if self.to_save == Some(ToSave::All) || create {
-            success = sql::execute(
+            sql::execute(
                 self.context,
                 sql,
 		"UPDATE acpeerstates \
@@ -450,10 +442,9 @@ impl<'a> Peerstate<'a> {
                     &self.verified_key_fingerprint,
                     &self.addr,
                 ],
-            ).is_ok();
-            assert_eq!(success, true);
+            )?
         } else if self.to_save == Some(ToSave::Timestamps) {
-            success = sql::execute(
+            sql::execute(
                 self.context,
                 sql,
                 "UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? \
@@ -464,15 +455,14 @@ impl<'a> Peerstate<'a> {
                     self.gossip_timestamp,
                     &self.addr
                 ],
-            )
-            .is_ok();
+            )?;
         }
 
         if self.to_save == Some(ToSave::All) || create {
             reset_gossiped_timestamp(self.context, 0);
         }
 
-        success
+        Ok(())
     }
 
     pub fn has_verified_key(&self, fingerprints: &HashSet<String>) -> bool {
@@ -522,7 +512,10 @@ mod tests {
             degrade_event: None,
         };
 
-        assert!(peerstate.save_to_db(&ctx.ctx.sql, true), "failed to save");
+        assert!(
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
+            "failed to save to db"
+        );
 
         let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr.into())
             .expect("failed to load peerstate from db");
@@ -564,7 +557,10 @@ mod tests {
             degrade_event: None,
         };
 
-        assert!(peerstate.save_to_db(&ctx.ctx.sql, true), "failed to save");
+        assert!(
+            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
+            "failed to save"
+        );
 
         let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr.into())
             .expect("failed to load peerstate from db");

src/securejoin.rs

@@ -678,7 +678,7 @@ fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Res
         if peerstate.set_verified(1, fingerprint.as_ref(), 2) {
             peerstate.prefer_encrypt = EncryptPreference::Mutual;
             peerstate.to_save = Some(ToSave::All);
-            peerstate.save_to_db(&context.sql, false);
+            peerstate.save_to_db(&context.sql, false).unwrap();
             return Ok(());
         }
     }

src/smtp.rs

@@ -70,8 +70,9 @@ impl Smtp {
         let port = lp.send_port as u16;
 
         let tls = native_tls::TlsConnector::builder()
-            // FIXME: unfortunately this is needed to make things work on macos + testrun.org
+            // 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();

src/sql.rs

@@ -777,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(())

src/test_utils.rs

@@ -76,7 +76,7 @@ pub fn configure_alice_keypair(ctx: &Context) -> String {
         KeyType::Private,
     )
     .unwrap();
-    let saved = key::dc_key_save_self_keypair(&ctx, &public, &private, &addr, 1, &ctx.sql);
+    let saved = key::dc_key_save_self_keypair(&ctx, &public, &private, &addr, true, &ctx.sql);
     assert_eq!(saved, true, "Failed to save Alice's key");
     addr
 }

src/wrapmime.rs

@@ -1,10 +1,12 @@
 use std::ffi::CString;
+use std::ptr;
 
 use crate::dc_tools::*;
 use crate::error::Error;
 use mmime::clist::*;
 use mmime::mailimf::types::*;
 use mmime::mailimf::types_helper::*;
+use mmime::mailmime::content::*;
 use mmime::mailmime::disposition::*;
 use mmime::mailmime::types::*;
 use mmime::mailmime::types_helper::*;
@@ -25,6 +27,134 @@ macro_rules! clist_append {
     };
 }
 
+/**************************************
+* mime parsing API
+**************************************/
+
+pub fn get_ct_subtype(mime: *mut Mailmime) -> Option<String> {
+    unsafe {
+        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
+        }
+    }
+}
+
+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.
+    */
+    unsafe {
+        ensure!(
+            (*mime_undetermined).mm_type == MAILMIME_MESSAGE as libc::c_int,
+            "Not a root mime message"
+        );
+        let mime = (*mime_undetermined).mm_data.mm_message.mm_msg_mime;
+
+        ensure!(
+            (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int
+                && "encrypted" == get_ct_subtype(mime).unwrap_or_default(),
+            "Not a multipart/encrypted message"
+        );
+        let parts: Vec<_> = (*(*mime).mm_data.mm_multipart.mm_mp_list)
+            .into_iter()
+            .map(|c| c as *mut Mailmime)
+            .collect();
+        ensure!(parts.len() == 2, "Invalid Autocrypt Level 1 Mime Parts");
+        // XXX ensure protocol-parameter "application/pgp-encrypted")
+        // XXX ensure wrapmime::get_content_type(parts[1])) == "application/octetstream"
+        // a proper OpenPGP multipart/encrypted Autocrypt Level 1 message
+        // https://tools.ietf.org/html/rfc3156.html#section-4
+        Ok((mime, parts[1]))
+    }
+}
+
+pub fn has_decryptable_data(mime_data: *mut mailmime_data) -> bool {
+    /* MAILMIME_DATA_FILE indicates, the data is in a file; AFAIK this is not used on parsing */
+    unsafe {
+        (*mime_data).dt_type == MAILMIME_DATA_TEXT as libc::c_int
+            && !(*mime_data).dt_data.dt_text.dt_data.is_null()
+            && (*mime_data).dt_data.dt_text.dt_length > 0
+    }
+}
+
+pub fn get_mime_transfer_encoding(mime: *mut Mailmime) -> Option<libc::c_int> {
+    unsafe {
+        let mm_mime_fields = (*mime).mm_mime_fields;
+        if !mm_mime_fields.is_null() {
+            for cur_data in (*(*mm_mime_fields).fld_list).into_iter() {
+                let field: *mut mailmime_field = cur_data as *mut _;
+                if (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int
+                    && !(*field).fld_data.fld_encoding.is_null()
+                {
+                    return Some((*(*field).fld_data.fld_encoding).enc_type);
+                }
+            }
+        }
+    }
+    None
+}
+
+pub fn decode_dt_data(
+    mime_data: *mut mailmime_data,
+    mime_transfer_encoding: libc::c_int,
+) -> Result<(*mut libc::c_char, libc::size_t), Error> {
+    // Decode data according to mime_transfer_encoding
+    // returns Ok with a (decoded_data,decoded_data_bytes) pointer
+    // where the caller must make sure to free it.
+    // It may return Ok(ptr::null_mut(), 0)
+
+    let mut transfer_decoding_buffer: *mut libc::c_char = ptr::null_mut();
+    let decoded_data: *mut libc::c_char;
+    let mut decoded_data_bytes: libc::size_t = 0;
+    if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int
+        || mime_transfer_encoding == MAILMIME_MECHANISM_8BIT as libc::c_int
+        || mime_transfer_encoding == MAILMIME_MECHANISM_BINARY as libc::c_int
+    {
+        unsafe {
+            decoded_data = (*mime_data).dt_data.dt_text.dt_data as *mut _;
+            decoded_data_bytes = (*mime_data).dt_data.dt_text.dt_length;
+        }
+        ensure!(
+            !decoded_data.is_null() && decoded_data_bytes > 0,
+            "could not decode mime message"
+        );
+    } else {
+        let mut current_index: libc::size_t = 0;
+        unsafe {
+            let r = mailmime_part_parse(
+                (*mime_data).dt_data.dt_text.dt_data,
+                (*mime_data).dt_data.dt_text.dt_length,
+                &mut current_index,
+                mime_transfer_encoding,
+                &mut transfer_decoding_buffer,
+                &mut decoded_data_bytes,
+            );
+            if r != MAILIMF_NO_ERROR as libc::c_int
+                || transfer_decoding_buffer.is_null()
+                || decoded_data_bytes <= 0
+            {
+                bail!("mailmime_part_parse returned error or invalid data");
+            }
+            decoded_data = transfer_decoding_buffer;
+        }
+    }
+    Ok((decoded_data, decoded_data_bytes))
+}
+
+/**************************************
+* mime creation API
+**************************************/
+
 pub fn add_filename_part(
     message: *mut Mailmime,
     basename: &str,

test-data/message/stress.txt

@@ -0,0 +1,125 @@
+-----BEGIN PGP MESSAGE-----
+Passphrase-Format: numeric9x4
+Passphrase-Begin: 17
+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+=9sJE
+-----END PGP MESSAGE-----