fix #615 -- like with c-core Chat-Version is left in unprotected headers because

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

deltachat-ffi/deltachat.h

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

deltachat-ffi/src/lib.rs

@@ -225,8 +225,8 @@ pub unsafe extern "C" fn dc_get_userdata(context: *mut dc_context_t) -> *mut lib
 #[no_mangle]
 pub unsafe extern "C" fn dc_open(
     context: *mut dc_context_t,
-    dbfile: *const libc::c_char,
-    blobdir: *const libc::c_char,
+    dbfile: *mut libc::c_char,
+    blobdir: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || dbfile.is_null() {
         eprintln!("ignoring careless call to dc_open()");
@@ -298,8 +298,8 @@ pub unsafe extern "C" fn dc_get_blobdir(context: *mut dc_context_t) -> *mut libc
 #[no_mangle]
 pub unsafe extern "C" fn dc_set_config(
     context: *mut dc_context_t,
-    key: *const libc::c_char,
-    value: *const libc::c_char,
+    key: *mut libc::c_char,
+    value: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || key.is_null() {
         eprintln!("ignoring careless call to dc_set_config()");
@@ -322,7 +322,7 @@ pub unsafe extern "C" fn dc_set_config(
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_config(
     context: *mut dc_context_t,
-    key: *const libc::c_char,
+    key: *mut libc::c_char,
 ) -> *mut libc::c_char {
     if context.is_null() || key.is_null() {
         eprintln!("ignoring careless call to dc_get_config()");
@@ -369,8 +369,8 @@ fn render_info(
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_oauth2_url(
     context: *mut dc_context_t,
-    addr: *const libc::c_char,
-    redirect: *const libc::c_char,
+    addr: *mut libc::c_char,
+    redirect: *mut libc::c_char,
 ) -> *mut libc::c_char {
     if context.is_null() {
         eprintln!("ignoring careless call to dc_get_oauth2_url()");
@@ -612,7 +612,7 @@ pub unsafe extern "C" fn dc_maybe_network(context: *mut dc_context_t) {
 pub unsafe extern "C" fn dc_get_chatlist(
     context: *mut dc_context_t,
     flags: libc::c_int,
-    query_str: *const libc::c_char,
+    query_str: *mut libc::c_char,
     query_id: u32,
 ) -> *mut dc_chatlist_t {
     if context.is_null() {
@@ -733,7 +733,7 @@ pub unsafe extern "C" fn dc_send_msg(
 pub unsafe extern "C" fn dc_send_text_msg(
     context: *mut dc_context_t,
     chat_id: u32,
-    text_to_send: *const libc::c_char,
+    text_to_send: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || text_to_send.is_null() {
         eprintln!("ignoring careless call to dc_send_text_msg()");
@@ -1017,7 +1017,7 @@ pub unsafe extern "C" fn dc_get_chat_contacts(
 pub unsafe extern "C" fn dc_search_msgs(
     context: *mut dc_context_t,
     chat_id: u32,
-    query: *const libc::c_char,
+    query: *mut libc::c_char,
 ) -> *mut dc_array::dc_array_t {
     if context.is_null() || query.is_null() {
         eprintln!("ignoring careless call to dc_search_msgs()");
@@ -1054,7 +1054,7 @@ pub unsafe extern "C" fn dc_get_chat(context: *mut dc_context_t, chat_id: u32) -
 pub unsafe extern "C" fn dc_create_group_chat(
     context: *mut dc_context_t,
     verified: libc::c_int,
-    name: *const libc::c_char,
+    name: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || name.is_null() {
         eprintln!("ignoring careless call to dc_create_group_chat()");
@@ -1131,7 +1131,7 @@ pub unsafe extern "C" fn dc_remove_contact_from_chat(
 pub unsafe extern "C" fn dc_set_chat_name(
     context: *mut dc_context_t,
     chat_id: u32,
-    name: *const libc::c_char,
+    name: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || chat_id <= constants::DC_CHAT_ID_LAST_SPECIAL as u32 || name.is_null() {
         eprintln!("ignoring careless call to dc_set_chat_name()");
@@ -1151,7 +1151,7 @@ pub unsafe extern "C" fn dc_set_chat_name(
 pub unsafe extern "C" fn dc_set_chat_profile_image(
     context: *mut dc_context_t,
     chat_id: u32,
-    image: *const libc::c_char,
+    image: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || chat_id <= constants::DC_CHAT_ID_LAST_SPECIAL as u32 {
         eprintln!("ignoring careless call to dc_set_chat_profile_image()");
@@ -1322,7 +1322,7 @@ pub unsafe extern "C" fn dc_get_msg(context: *mut dc_context_t, msg_id: u32) ->
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn dc_may_be_valid_addr(addr: *const libc::c_char) -> libc::c_int {
+pub unsafe extern "C" fn dc_may_be_valid_addr(addr: *mut libc::c_char) -> libc::c_int {
     if addr.is_null() {
         eprintln!("ignoring careless call to dc_may_be_valid_addr()");
         return 0;
@@ -1334,7 +1334,7 @@ pub unsafe extern "C" fn dc_may_be_valid_addr(addr: *const libc::c_char) -> libc
 #[no_mangle]
 pub unsafe extern "C" fn dc_lookup_contact_id_by_addr(
     context: *mut dc_context_t,
-    addr: *const libc::c_char,
+    addr: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || addr.is_null() {
         eprintln!("ignoring careless call to dc_lookup_contact_id_by_addr()");
@@ -1349,8 +1349,8 @@ pub unsafe extern "C" fn dc_lookup_contact_id_by_addr(
 #[no_mangle]
 pub unsafe extern "C" fn dc_create_contact(
     context: *mut dc_context_t,
-    name: *const libc::c_char,
-    addr: *const libc::c_char,
+    name: *mut libc::c_char,
+    addr: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || addr.is_null() {
         eprintln!("ignoring careless call to dc_create_contact()");
@@ -1369,7 +1369,7 @@ pub unsafe extern "C" fn dc_create_contact(
 #[no_mangle]
 pub unsafe extern "C" fn dc_add_address_book(
     context: *mut dc_context_t,
-    addr_book: *const libc::c_char,
+    addr_book: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null() || addr_book.is_null() {
         eprintln!("ignoring careless call to dc_add_address_book()");
@@ -1390,7 +1390,7 @@ pub unsafe extern "C" fn dc_add_address_book(
 pub unsafe extern "C" fn dc_get_contacts(
     context: *mut dc_context_t,
     flags: u32,
-    query: *const libc::c_char,
+    query: *mut libc::c_char,
 ) -> *mut dc_array::dc_array_t {
     if context.is_null() {
         eprintln!("ignoring careless call to dc_get_contacts()");
@@ -1521,31 +1521,23 @@ pub unsafe extern "C" fn dc_get_contact(
 pub unsafe extern "C" fn dc_imex(
     context: *mut dc_context_t,
     what: libc::c_int,
-    param1: *const libc::c_char,
-    _param2: *const libc::c_char,
+    param1: *mut libc::c_char,
+    _param2: *mut libc::c_char,
 ) {
     if context.is_null() {
         eprintln!("ignoring careless call to dc_imex()");
         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| imex::imex(ctx, what, as_opt_str(param1)))
+        .with_inner(|ctx| dc_imex::dc_imex(ctx, what, as_opt_str(param1)))
         .ok();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn dc_imex_has_backup(
     context: *mut dc_context_t,
-    dir: *const libc::c_char,
+    dir: *mut libc::c_char,
 ) -> *mut libc::c_char {
     if context.is_null() || dir.is_null() {
         eprintln!("ignoring careless call to dc_imex_has_backup()");
@@ -1553,7 +1545,7 @@ pub unsafe extern "C" fn dc_imex_has_backup(
     }
     let ffi_context = &*context;
     ffi_context
-        .with_inner(|ctx| match imex::has_backup(ctx, as_str(dir)) {
+        .with_inner(|ctx| match dc_imex::dc_imex_has_backup(ctx, as_str(dir)) {
             Ok(res) => res.strdup(),
             Err(err) => {
                 error!(ctx, "dc_imex_has_backup: {}", err);
@@ -1571,13 +1563,7 @@ pub unsafe extern "C" fn dc_initiate_key_transfer(context: *mut dc_context_t) ->
     }
     let ffi_context = &*context;
     ffi_context
-        .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()
-            }
-        })
+        .with_inner(|ctx| dc_imex::dc_initiate_key_transfer(ctx))
         .unwrap_or_else(|_| ptr::null_mut())
 }
 
@@ -1585,7 +1571,7 @@ pub unsafe extern "C" fn dc_initiate_key_transfer(context: *mut dc_context_t) ->
 pub unsafe extern "C" fn dc_continue_key_transfer(
     context: *mut dc_context_t,
     msg_id: u32,
-    setup_code: *const libc::c_char,
+    setup_code: *mut libc::c_char,
 ) -> libc::c_int {
     if context.is_null()
         || msg_id <= constants::DC_MSG_ID_LAST_SPECIAL as u32
@@ -1596,15 +1582,15 @@ pub unsafe extern "C" fn dc_continue_key_transfer(
     }
     let ffi_context = &*context;
     ffi_context
-        .with_inner(
-            |ctx| match imex::continue_key_transfer(ctx, msg_id, as_str(setup_code)) {
+        .with_inner(|ctx| {
+            match dc_imex::dc_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)
 }
 
@@ -1623,7 +1609,7 @@ pub unsafe extern "C" fn dc_stop_ongoing_process(context: *mut dc_context_t) {
 #[no_mangle]
 pub unsafe extern "C" fn dc_check_qr(
     context: *mut dc_context_t,
-    qr: *const libc::c_char,
+    qr: *mut libc::c_char,
 ) -> *mut dc_lot_t {
     if context.is_null() || qr.is_null() {
         eprintln!("ignoring careless call to dc_check_qr()");
@@ -1660,7 +1646,7 @@ pub unsafe extern "C" fn dc_get_securejoin_qr(
 #[no_mangle]
 pub unsafe extern "C" fn dc_join_securejoin(
     context: *mut dc_context_t,
-    qr: *const libc::c_char,
+    qr: *mut libc::c_char,
 ) -> u32 {
     if context.is_null() || qr.is_null() {
         eprintln!("ignoring careless call to dc_join_securejoin()");
@@ -2577,7 +2563,7 @@ pub unsafe extern "C" fn dc_msg_get_setupcodebegin(msg: *mut dc_msg_t) -> *mut l
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn dc_msg_set_text(msg: *mut dc_msg_t, text: *const libc::c_char) {
+pub unsafe extern "C" fn dc_msg_set_text(msg: *mut dc_msg_t, text: *mut libc::c_char) {
     if msg.is_null() {
         eprintln!("ignoring careless call to dc_msg_set_text()");
         return;
@@ -2590,8 +2576,8 @@ pub unsafe extern "C" fn dc_msg_set_text(msg: *mut dc_msg_t, text: *const libc::
 #[no_mangle]
 pub unsafe extern "C" fn dc_msg_set_file(
     msg: *mut dc_msg_t,
-    file: *const libc::c_char,
-    filemime: *const libc::c_char,
+    file: *mut libc::c_char,
+    filemime: *mut libc::c_char,
 ) {
     if msg.is_null() || file.is_null() {
         eprintln!("ignoring careless call to dc_msg_set_file()");

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,13 +96,22 @@ 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, "import", 0, 0) };
+    unsafe {
+        dc_receive_imf(
+            context,
+            data.as_ptr() as *const _,
+            data.len(),
+            "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 imex().
+/// For normal importing, use dc_imex().
 ///
 /// @private @memberof Context
 /// @param context The context as created by dc_context_new().
@@ -405,13 +414,18 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                  ============================================="
             ),
         },
-        "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),
-        },
+        "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");
+            };
+        }
         "get-setupcodebegin" => {
             ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
             let msg_id: u32 = arg1.parse()?;
@@ -432,28 +446,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"
             );
-            continue_key_transfer(context, arg1.parse()?, &arg2)?;
+            dc_continue_key_transfer(context, arg1.parse()?, &arg2)?;
         }
         "has-backup" => {
-            has_backup(context, blobdir)?;
+            dc_imex_has_backup(context, blobdir)?;
         }
         "export-backup" => {
-            imex(context, ImexMode::ExportBackup, Some(blobdir));
+            dc_imex(context, 11, Some(blobdir));
         }
         "import-backup" => {
             ensure!(!arg1.is_empty(), "Argument <backup-file> missing.");
-            imex(context, ImexMode::ImportBackup, Some(arg1));
+            dc_imex(context, 12, Some(arg1));
         }
         "export-keys" => {
-            imex(context, ImexMode::ExportSelfKeys, Some(blobdir));
+            dc_imex(context, 1, Some(blobdir));
         }
         "import-keys" => {
-            imex(context, ImexMode::ImportSelfKeys, Some(blobdir));
+            dc_imex(context, 2, Some(blobdir));
         }
         "export-setup" => {
-            let setup_code = create_setup_code(context);
+            let setup_code = dc_create_setup_code(context);
             let file_name = blobdir.join("autocrypt-setup-message.html");
-            let file_content = render_setup_file(context, &setup_code)?;
+            let file_content = dc_render_setup_file(context, &setup_code)?;
             std::fs::write(&file_name, file_content)?;
             println!(
                 "Setup message written to: {}\nSetup code: {}",

mmime/src/display.rs

@@ -1,386 +0,0 @@
-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,7 +19,6 @@
 pub mod charconv;
 pub mod chash;
 pub mod clist;
-pub mod display;
 pub mod mailimf;
 pub mod mailmime;
 pub mod mmapstring;
@@ -28,7 +27,6 @@ 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::*;
@@ -37,6 +35,10 @@ 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() {
@@ -75,4 +77,384 @@ 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
+            }
+        }
+    }
 }

mmime/src/mailimf/types.rs

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

mmime/src/mailmime/types.rs

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

proptest-regressions/dc_strencode.txt

@@ -5,4 +5,3 @@
 # 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"

src/constants.rs

@@ -64,6 +64,15 @@ 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/contact.rs

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

src/dc_imex.rs

@@ -2,7 +2,10 @@ use std::ffi::CString;
 use std::path::Path;
 use std::ptr;
 
-use num_traits::FromPrimitive;
+use libc::{free, strlen};
+use mmime::mailmime::content::*;
+use mmime::mmapstring::*;
+use mmime::other::*;
 use rand::{thread_rng, Rng};
 
 use crate::chat;
@@ -22,48 +25,12 @@ use crate::pgp::*;
 use crate::sql::{self, Sql};
 use crate::stock::StockMessage;
 
-#[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>>) {
+// 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>>) {
     let mut param = Params::new();
     param.set_int(Param::Cmd, what as i32);
     if let Some(param1) = param1 {
@@ -75,7 +42,7 @@ pub fn imex(context: &Context, what: ImexMode, param1: Option<impl AsRef<Path>>)
 }
 
 /// Returns the filename of the backup if found, nullptr otherwise.
-pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<String> {
+pub fn dc_imex_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;
@@ -108,10 +75,12 @@ pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<Strin
     }
 }
 
-pub fn initiate_key_transfer(context: &Context) -> Result<String> {
+pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
     let mut msg: Message;
-    ensure!(dc_alloc_ongoing(context), "could not allocate ongoing");
-    let setup_code = create_setup_code(context);
+    if !dc_alloc_ongoing(context) {
+        return std::ptr::null_mut();
+    }
+    let setup_code = dc_create_setup_code(context);
     /* this may require a keypair to be created. this may take a second ... */
     if !context
         .running_state
@@ -120,7 +89,7 @@ pub fn initiate_key_transfer(context: &Context) -> Result<String> {
         .unwrap()
         .shall_stop_ongoing
     {
-        if let Ok(ref setup_file_content) = render_setup_file(context, &setup_code) {
+        if let Ok(ref setup_file_content) = dc_render_setup_file(context, &setup_code) {
             /* encrypting may also take a while ... */
             if !context
                 .running_state
@@ -180,13 +149,13 @@ pub fn initiate_key_transfer(context: &Context) -> Result<String> {
     }
     dc_free_ongoing(context);
 
-    Ok(setup_code)
+    setup_code.strdup()
 }
 
 /// Renders HTML body of a setup file message.
 ///
 /// The `passphrase` must be at least 2 characters long.
-pub fn render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
+pub fn dc_render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
     ensure!(
         passphrase.len() >= 2,
         "Passphrase must be at least 2 chars long."
@@ -236,7 +205,7 @@ pub fn render_setup_file(context: &Context, passphrase: &str) -> Result<String>
     ))
 }
 
-pub fn create_setup_code(_context: &Context) -> String {
+pub fn dc_create_setup_code(_context: &Context) -> String {
     let mut random_val: u16;
     let mut rng = thread_rng();
     let mut ret = String::new();
@@ -244,22 +213,22 @@ pub fn create_setup_code(_context: &Context) -> String {
     for i in 0..9 {
         loop {
             random_val = rng.gen();
-            if !(random_val as usize > 60000) {
+            if !(random_val as libc::c_int > 60000) {
                 break;
             }
         }
-        random_val = (random_val as usize % 10000) as u16;
+        random_val = (random_val as libc::c_int % 10000) as u16;
         ret += &format!(
             "{}{:04}",
             if 0 != i { "-" } else { "" },
-            random_val as usize
+            random_val as libc::c_int,
         );
     }
 
     ret
 }
 
-pub fn continue_key_transfer(context: &Context, msg_id: u32, setup_code: &str) -> Result<()> {
+pub fn dc_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);
@@ -273,14 +242,17 @@ pub fn continue_key_transfer(context: &Context, msg_id: u32, setup_code: &str) -
     );
 
     if let Some(filename) = msg.get_file(context) {
-        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.")
+        if let Ok(buf) = dc_read_file(context, filename) {
+            let norm_sc = CString::yolo(dc_normalize_setup_code(setup_code));
+            unsafe {
+                if let Ok(armored_key) =
+                    dc_decrypt_setup_file(context, norm_sc.as_ptr(), buf.as_ptr().cast())
+                {
+                    set_self_key(context, &armored_key, true, true)?;
+                } else {
+                    bail!("Bad setup code.")
+                }
             }
-
             Ok(())
         } else {
             bail!("Cannot read Autocrypt Setup Message file.");
@@ -350,7 +322,7 @@ fn set_self_key(
         &public_key,
         &private_key,
         self_addr.unwrap(),
-        set_default,
+        set_default as libc::c_int,
         &context.sql,
     ) {
         bail!("Cannot save keypair, internal key-state possibly corrupted now!");
@@ -358,56 +330,65 @@ fn set_self_key(
     Ok(())
 }
 
-fn decrypt_setup_file(
-    _context: &Context,
-    passphrase: impl AsRef<str>,
-    filecontent: &mut [u8],
+pub unsafe fn dc_decrypt_setup_file(
+    context: &Context,
+    passphrase: *const libc::c_char,
+    filecontent: *const libc::c_char,
 ) -> Result<String> {
+    let fc_buf: *mut libc::c_char;
     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 split_result = unsafe {
-        dc_split_armored_data(
-            filecontent.as_mut_ptr().cast(),
-            &mut fc_headerline,
-            ptr::null_mut(),
-            ptr::null_mut(),
-            &mut fc_base64,
-        )
-    };
+    let mut payload: Result<String> = Err(format_err!("Failed to decrypt"));
 
-    if !split_result || fc_headerline != "-----BEGIN PGP MESSAGE-----" || fc_base64.is_null() {
-        bail!("Invalid armored data");
+    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) => payload = Ok(String::from_utf8(plain).unwrap()),
+                Err(err) => {
+                    error!(context, "Failed to decrypt message: {:?}", err);
+                    payload = Err(err);
+                }
+            }
+        }
     }
 
-    // convert base64 to binary
-    let base64_encoded =
-        unsafe { std::slice::from_raw_parts(fc_base64 as *const u8, libc::strlen(fc_base64)) };
+    free(fc_buf as *mut libc::c_void);
+    if !binary.is_null() {
+        mmap_string_unref(binary);
+    }
 
-    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)
+    payload
 }
 
-/// 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 {
+pub fn dc_normalize_setup_code(s: &str) -> String {
     let mut out = String::new();
     for c in s.chars() {
         if c >= '0' && c <= '9' {
@@ -421,9 +402,9 @@ pub fn normalize_setup_code(s: &str) -> String {
 }
 
 #[allow(non_snake_case)]
-pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
+pub fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     ensure!(dc_alloc_ongoing(context), "could not allocate ongoing");
-    let what: Option<ImexMode> = job.param.get_int(Param::Cmd).and_then(ImexMode::from_i32);
+    let what = job.param.get_int(Param::Cmd).unwrap_or_default();
     let param = job.param.get(Param::Arg).unwrap_or_default();
 
     ensure!(!param.is_empty(), "No Import/export dir/file given.");
@@ -431,8 +412,8 @@ pub fn 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 == Some(ImexMode::ExportBackup) || what == Some(ImexMode::ExportSelfKeys) {
-        // before we export anything, make sure the private key exists
+    if what == DC_IMEX_EXPORT_BACKUP || what == DC_IMEX_EXPORT_SELF_KEYS {
+        /* 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.");
@@ -442,12 +423,12 @@ pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     }
     let path = Path::new(param);
     let success = match 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_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);
         }
     };
     dc_free_ongoing(context);
@@ -464,7 +445,11 @@ pub fn job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) -> Result<()> {
     }
 }
 
-/// Import Backup
+/*******************************************************************************
+ * Import backup
+ ******************************************************************************/
+
+#[allow(non_snake_case)]
 fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Result<()> {
     info!(
         context,
@@ -540,13 +525,13 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
                     continue;
                 }
 
-                let path_filename = context.get_blobdir().join(file_name);
-                if dc_write_file(context, &path_filename, &file_blob) {
+                let pathNfilename = context.get_blobdir().join(file_name);
+                if dc_write_file(context, &pathNfilename, &file_blob) {
                     continue;
                 }
                 bail!(
                     "Storage full? Cannot write file {} with {} bytes.",
-                    path_filename.display(),
+                    pathNfilename.display(),
                     file_blob.len(),
                 );
             }
@@ -567,8 +552,9 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
  ******************************************************************************/
 /* the FILE_PROGRESS macro calls the callback with the permille of files processed.
 The macro avoids weird values of 0% or 100% while still working. */
-fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
-    let mut ok_to_continue = true;
+#[allow(non_snake_case)]
+unsafe fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
+    let mut ok_to_continue: bool;
     let mut success = false;
 
     let mut delete_dest_file: libc::c_int = 0;
@@ -585,55 +571,54 @@ 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(),
     );
-    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 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;
             }
-        }
-        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();
@@ -666,9 +651,9 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
                                                     continue;
                                                 } else {
                                                     info!(context, "EXPORTing filename={}", name);
-                                                    let curr_path_filename = context.get_blobdir().join(entry.file_name());
+                                                    let curr_pathNfilename = context.get_blobdir().join(entry.file_name());
                                                     if let Ok(buf) =
-                                                        dc_read_file(context, &curr_path_filename)
+                                                        dc_read_file(context, &curr_pathNfilename)
                                                     {
                                                         if buf.is_empty() {
                                                             continue;
@@ -677,7 +662,7 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
                                                             error!(
                                                                 context,
                                                                 "Disk full? Cannot add file \"{}\" to backup.",
-                                                                curr_path_filename.display(),
+                                                                curr_pathNfilename.display(),
                                                             );
                                                             /* this is not recoverable! writing to the sqlite database should work! */
                                                             ok_to_continue = false;
@@ -692,34 +677,39 @@ 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 {
-                        error!(
-                            context,
-                            "Backup: Cannot copy from blob-directory \"{}\".",
-                            context.get_blobdir().display(),
-                        );
+                        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;
+                        }
                     }
                 } else {
-                    info!(context, "Backup: No files to copy.",);
-                }
-                if ok_to_continue {
-                    if sql
-                        .set_config_int(context, "backup_time", now as i32)
-                        .is_ok()
-                    {
-                        context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
-                        success = true;
-                    }
-                }
-            } else {
-                error!(
-                    context,
-                    "Backup: Cannot get info for blob-directory \"{}\".",
-                    context.get_blobdir().display(),
-                );
-            };
+                    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);
     }
@@ -789,7 +779,7 @@ fn import_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
                     ptr::null_mut(),
                     ptr::null_mut(),
                 );
-                libc::free(buf2 as *mut libc::c_void);
+                free(buf2 as *mut libc::c_void);
             }
             if split_res
                 && buf2_headerline.contains("-----BEGIN PGP PUBLIC KEY BLOCK-----")
@@ -900,7 +890,7 @@ mod tests {
         let t = test_context(Some(Box::new(logging_cb)));
 
         configure_alice_keypair(&t.ctx);
-        let msg = render_setup_file(&t.ctx, "hello").unwrap();
+        let msg = dc_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
@@ -926,10 +916,10 @@ mod tests {
     }
 
     #[test]
-    fn otest_render_setup_file_newline_replace() {
+    fn test_render_setup_file_newline_replace() {
         let t = test_context(Some(Box::new(ac_setup_msg_cb)));
         configure_alice_keypair(&t.ctx);
-        let msg = render_setup_file(&t.ctx, "pw").unwrap();
+        let msg = dc_render_setup_file(&t.ctx, "pw").unwrap();
         println!("{}", &msg);
         assert!(msg.contains("<p>hello<br>there</p>"));
     }
@@ -937,7 +927,7 @@ mod tests {
     #[test]
     fn test_create_setup_code() {
         let t = dummy_context();
-        let setupcode = create_setup_code(&t.ctx);
+        let setupcode = dc_create_setup_code(&t.ctx);
         assert_eq!(setupcode.len(), 44);
         assert_eq!(setupcode.chars().nth(4).unwrap(), '-');
         assert_eq!(setupcode.chars().nth(9).unwrap(), '-');
@@ -965,65 +955,12 @@ mod tests {
 
     #[test]
     fn test_normalize_setup_code() {
-        let norm = normalize_setup_code("123422343234423452346234723482349234");
+        let norm = dc_normalize_setup_code("123422343234423452346234723482349234");
         assert_eq!(norm, "1234-2234-3234-4234-5234-6234-7234-8234-9234");
 
-        let norm =
-            normalize_setup_code("\t1 2 3422343234- foo bar-- 423-45 2 34 6234723482349234      ");
+        let norm = dc_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/dc_mimeparser.rs

@@ -5,6 +5,7 @@ use std::ptr;
 use charset::Charset;
 use deltachat_derive::{FromSql, ToSql};
 use libc::{strcmp, strlen, strncmp};
+use mmime::clist::*;
 use mmime::mailimf::types::*;
 use mmime::mailimf::*;
 use mmime::mailmime::content::*;
@@ -20,7 +21,7 @@ use crate::context::Context;
 use crate::dc_simplify::*;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
-use crate::e2ee;
+use crate::e2ee::*;
 use crate::error::Error;
 use crate::location;
 use crate::param::*;
@@ -37,9 +38,7 @@ pub struct MimeParser<'a> {
     pub subject: Option<String>,
     pub is_send_by_messenger: bool,
     pub decrypting_failed: bool,
-    pub encrypted: bool,
-    pub signatures: HashSet<String>,
-    pub gossipped_addr: HashSet<String>,
+    pub e2ee_helper: E2eeHelper,
     pub is_forwarded: bool,
     pub reports: Vec<*mut Mailmime>,
     pub is_system_message: SystemMessage,
@@ -93,9 +92,7 @@ impl<'a> MimeParser<'a> {
             subject: None,
             is_send_by_messenger: false,
             decrypting_failed: false,
-            encrypted: false,
-            signatures: Default::default(),
-            gossipped_addr: Default::default(),
+            e2ee_helper: Default::default(),
             is_forwarded: false,
             context,
             reports: Vec::new(),
@@ -105,7 +102,7 @@ impl<'a> MimeParser<'a> {
         }
     }
 
-    pub unsafe fn parse(&mut self, body: &[u8]) -> Result<(), Error> {
+    pub unsafe fn parse(&mut self, body: &[u8]) {
         let mut index = 0;
 
         let r = mailmime_parse(
@@ -116,11 +113,7 @@ impl<'a> MimeParser<'a> {
         );
 
         if r == MAILIMF_NO_ERROR as libc::c_int && !self.mimeroot.is_null() {
-            let (encrypted, signatures, gossipped_addr) =
-                e2ee::try_decrypt(self.context, self.mimeroot)?;
-            self.encrypted = encrypted;
-            self.signatures = signatures;
-            self.gossipped_addr = gossipped_addr;
+            self.e2ee_helper.decrypt(self.context, self.mimeroot);
             self.parse_mime_recursive(self.mimeroot);
 
             if let Some(field) = self.lookup_field("Subject") {
@@ -324,7 +317,6 @@ impl<'a> MimeParser<'a> {
             }
             self.parts.push(part_5);
         }
-        Ok(())
     }
 
     pub fn get_last_nonmeta(&mut self) -> Option<&mut Part> {
@@ -801,9 +793,9 @@ impl<'a> MimeParser<'a> {
     }
 
     fn do_add_single_part(&mut self, mut part: Part) {
-        if self.encrypted && self.signatures.len() > 0 {
+        if self.e2ee_helper.encrypted && self.e2ee_helper.signatures.len() > 0 {
             part.param.set_int(Param::GuranteeE2ee, 1);
-        } else if self.encrypted {
+        } else if self.e2ee_helper.encrypted {
             part.param.set_int(Param::ErroneousE2ee, 0x2);
         }
         self.parts.push(part);
@@ -897,6 +889,7 @@ impl<'a> Drop for MimeParser<'a> {
         if !self.mimeroot.is_null() {
             unsafe { mailmime_free(self.mimeroot) };
         }
+        unsafe { self.e2ee_helper.thanks() };
     }
 }
 
@@ -1063,8 +1056,7 @@ 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") => {
-                        // maybe try_decrypt failed to decrypt
-                        // or it wasn't in proper Autocrypt format
+                        // decryptable parts are already converted to other mime parts in dc_e2ee_decrypt()
                         DC_MIMETYPE_MP_NOT_DECRYPTABLE
                     }
                     Some("signed") => DC_MIMETYPE_MP_SIGNED,
@@ -1211,61 +1203,50 @@ pub unsafe fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, E
     Err(format_err!("Failed to to decode"))
 }
 
-pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String> {
+pub unsafe fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String> {
     /* returned addresses are normalized. */
     let mut recipients: HashSet<String> = Default::default();
 
-    for cur in unsafe { (*(*imffields).fld_list).into_iter() } {
+    for cur in (*(*imffields).fld_list).into_iter() {
         let fld = cur as *mut mailimf_field;
 
         let fld_to: *mut mailimf_to;
         let fld_cc: *mut mailimf_cc;
 
         let mut addr_list: *mut mailimf_address_list = ptr::null_mut();
-        if fld.is_null() {
-            continue;
-        }
-
-        let fld = unsafe { *fld };
-
         // TODO match on enums /rtn
-        match fld.fld_type {
+        match (*fld).fld_type {
             13 => {
-                fld_to = unsafe { fld.fld_data.fld_to };
+                fld_to = (*fld).fld_data.fld_to;
                 if !fld_to.is_null() {
-                    addr_list = unsafe { (*fld_to).to_addr_list };
+                    addr_list = (*fld_to).to_addr_list
                 }
             }
             14 => {
-                fld_cc = unsafe { fld.fld_data.fld_cc };
+                fld_cc = (*fld).fld_data.fld_cc;
                 if !fld_cc.is_null() {
-                    addr_list = unsafe { (*fld_cc).cc_addr_list };
+                    addr_list = (*fld_cc).cc_addr_list
                 }
             }
             _ => {}
         }
 
         if !addr_list.is_null() {
-            for cur2 in unsafe { &(*(*addr_list).ad_list) } {
+            for cur2 in (*(*addr_list).ad_list).into_iter() {
                 let adr = cur2 as *mut mailimf_address;
 
-                if adr.is_null() {
-                    continue;
-                }
-                let adr = unsafe { *adr };
-
-                if adr.ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
-                    mailimf_get_recipients_add_addr(&mut recipients, unsafe {
-                        adr.ad_data.ad_mailbox
-                    });
-                } else if adr.ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
-                    let group = unsafe { adr.ad_data.ad_group };
-                    if !group.is_null() && unsafe { !(*group).grp_mb_list.is_null() } {
-                        for cur3 in unsafe { &(*(*(*group).grp_mb_list).mb_list) } {
-                            mailimf_get_recipients_add_addr(
-                                &mut recipients,
-                                cur3 as *mut mailimf_mailbox,
-                            );
+                if !adr.is_null() {
+                    if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
+                        mailimf_get_recipients_add_addr(&mut recipients, (*adr).ad_data.ad_mailbox);
+                    } else if (*adr).ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
+                        let group: *mut mailimf_group = (*adr).ad_data.ad_group;
+                        if !group.is_null() && !(*group).grp_mb_list.is_null() {
+                            for cur3 in (*(*(*group).grp_mb_list).mb_list).into_iter() {
+                                mailimf_get_recipients_add_addr(
+                                    &mut recipients,
+                                    cur3 as *mut mailimf_mailbox,
+                                );
+                            }
                         }
                     }
                 }
@@ -1284,26 +1265,30 @@ fn mailimf_get_recipients_add_addr(recipients: &mut HashSet<String>, mb: *mut ma
 }
 
 /*the result is a pointer to mime, must not be freed*/
-pub fn mailimf_find_field(
+pub unsafe fn mailimf_find_field(
     header: *mut mailimf_fields,
     wanted_fld_type: libc::c_int,
 ) -> *mut mailimf_field {
-    if header.is_null() {
+    if header.is_null() || (*header).fld_list.is_null() {
         return ptr::null_mut();
     }
-
-    let header = unsafe { (*header) };
-    if header.fld_list.is_null() {
-        return ptr::null_mut();
-    }
-
-    for cur in unsafe { &(*header.fld_list) } {
-        let field = cur as *mut mailimf_field;
+    let mut cur1: *mut clistiter = (*(*header).fld_list).first;
+    while !cur1.is_null() {
+        let field: *mut mailimf_field = (if !cur1.is_null() {
+            (*cur1).data
+        } else {
+            ptr::null_mut()
+        }) as *mut mailimf_field;
         if !field.is_null() {
-            if unsafe { (*field).fld_type } == wanted_fld_type {
+            if (*field).fld_type == wanted_fld_type {
                 return field;
             }
         }
+        cur1 = if !cur1.is_null() {
+            (*cur1).next
+        } else {
+            ptr::null_mut()
+        }
     }
 
     ptr::null_mut()
@@ -1441,7 +1426,7 @@ mod tests {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
         let mut mimeparser = MimeParser::new(&context.ctx);
-        unsafe { mimeparser.parse(&raw[..]).unwrap() };
+        unsafe { mimeparser.parse(&raw[..]) };
         assert_eq!(mimeparser.subject, None);
         assert_eq!(mimeparser.parts.len(), 1);
     }
@@ -1451,7 +1436,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()).unwrap() };
+            unsafe { mimeparser.parse(data.as_bytes()) };
         }
     }
 
@@ -1460,7 +1445,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[..]).unwrap() };
+        unsafe { mimeparser.parse(&raw[..]) };
         assert_eq!(
             mimeparser.get_rfc724_mid(),
             Some("2dfdbde7@example.org".into())
@@ -1472,7 +1457,7 @@ mod tests {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
         let mut mimeparser = MimeParser::new(&context.ctx);
-        unsafe { mimeparser.parse(&raw[..]).unwrap() };
+        unsafe { mimeparser.parse(&raw[..]) };
         assert_eq!(mimeparser.get_rfc724_mid(), None);
     }
 
@@ -1482,7 +1467,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[..]).unwrap();
+            mimeparser.parse(&raw[..]);
 
             assert_eq!(mimeparser.subject, Some("inner-subject".into()));
 

src/dc_receive_imf.rs

@@ -39,7 +39,8 @@ enum CreateEvent {
 /// Receive a message and add it to the database.
 pub unsafe fn dc_receive_imf(
     context: &Context,
-    imf_raw: &[u8],
+    imf_raw_not_terminated: *const libc::c_char,
+    imf_raw_bytes: libc::size_t,
     server_folder: impl AsRef<str>,
     server_uid: u32,
     flags: u32,
@@ -60,10 +61,9 @@ 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);
-    if let Err(err) = mime_parser.parse(imf_raw) {
-        error!(context, "dc_receive_imf parse error: {}", err);
-    };
+    mime_parser.parse(body);
 
     if mime_parser.header.is_empty() {
         // Error - even adding an empty record won't help as we do not know the message ID
@@ -204,7 +204,8 @@ pub unsafe fn dc_receive_imf(
         if let Err(err) = add_parts(
             context,
             &mut mime_parser,
-            imf_raw,
+            imf_raw_not_terminated,
+            imf_raw_bytes,
             incoming,
             &mut incoming_origin,
             server_folder.as_ref(),
@@ -291,7 +292,8 @@ pub unsafe fn dc_receive_imf(
 unsafe fn add_parts(
     context: &Context,
     mut mime_parser: &mut MimeParser,
-    imf_raw: &[u8],
+    imf_raw_not_terminated: *const libc::c_char,
+    imf_raw_bytes: libc::size_t,
     incoming: i32,
     incoming_origin: &mut Origin,
     server_folder: impl AsRef<str>,
@@ -610,7 +612,7 @@ unsafe fn add_parts(
     let icnt = mime_parser.parts.len();
     let mut txt_raw = None;
 
-    context
+    let is_ok = context
         .sql
         .prepare(
             "INSERT INTO msgs \
@@ -681,7 +683,10 @@ unsafe fn add_parts(
                         part.bytes,
                         *hidden,
                         if save_mime_headers {
-                            Some(String::from_utf8_lossy(imf_raw))
+                            Some(String::from_utf8_lossy(std::slice::from_raw_parts(
+                                imf_raw_not_terminated as *const u8,
+                                imf_raw_bytes,
+                            )))
                         } else {
                             None
                         },
@@ -697,10 +702,13 @@ unsafe fn add_parts(
                 Ok(())
             },
         )
-        .map_err(|err| {
-            cleanup(mime_in_reply_to, mime_references);
-            err
-        })?;
+        .is_ok();
+
+    if !is_ok {
+        // i/o error - there is nothing more we can do - in other cases, we try to write at least an empty record
+        cleanup(mime_in_reply_to, mime_references);
+        bail!("Cannot write DB.");
+    }
 
     info!(
         context,
@@ -1147,15 +1155,21 @@ 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 {
-        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);
-            }
+        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));
         }
+
+        free(failure_reason.cast());
     }
 
     // check if the sender is a member of the existing group -
@@ -1184,14 +1198,18 @@ 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 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);
+            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));
             }
+            free(failure_reason.cast());
         }
         if 0 == allow_creation {
             cleanup(ret_chat_id, ret_chat_id_blocked, chat_id, chat_id_blocked);
@@ -1598,38 +1616,51 @@ fn search_chat_ids_by_contact_ids(context: &Context, unsorted_contact_ids: &Vec<
     chat_ids
 }
 
-fn check_verified_properties(
+unsafe fn check_verified_properties(
     context: &Context,
     mimeparser: &MimeParser,
     from_id: u32,
     to_ids: &Vec<u32>,
-) -> Result<()> {
-    let contact = Contact::load_from_db(context, from_id)?;
+    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);
+    };
 
-    ensure!(mimeparser.encrypted, "This message is not encrypted.");
+    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, 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 != DC_CONTACT_ID_SELF {
+    if from_id != 1 {
         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
         {
-            bail!(
-                "Sender of this message is not verified: {}",
-                contact.get_addr()
-            );
+            verify_fail("The sender of this message is not verified.".into());
+            return 0;
         }
 
         if let Some(peerstate) = peerstate {
-            ensure!(
-                peerstate.has_verified_key(&mimeparser.signatures),
-                "The message was sent with non-verified encryption."
-            );
+            if !peerstate.has_verified_key(&mimeparser.e2ee_helper.signatures) {
+                verify_fail("The message was sent with non-verified encryption.".into());
+                return 0;
+            }
         }
     }
 
@@ -1642,19 +1673,19 @@ fn check_verified_properties(
             to_ids_str,
         ),
         params![],
-        |row| Ok((row.get::<_, String>(0)?, row.get::<_, i32>(1).unwrap_or(0))),
+        |row| Ok((row.get::<_, String>(0)?, row.get::<_, i32>(1)?)),
         |rows| {
             rows.collect::<std::result::Result<Vec<_>, _>>()
                 .map_err(Into::into)
         },
-    )?;
+    );
 
-    for (to_addr, _is_verified) in rows.into_iter() {
-        let mut is_verified = _is_verified != 0;
+    if rows.is_err() {
+        return 0;
+    }
+    for (to_addr, mut is_verified) in rows.unwrap().into_iter() {
         let mut peerstate = Peerstate::from_addr(context, &context.sql, &to_addr);
-
-        // mark gossiped keys (if any) as verified
-        if mimeparser.gossipped_addr.contains(&to_addr) && peerstate.is_some() {
+        if mimeparser.e2ee_helper.gossipped_addr.contains(&to_addr) && peerstate.is_some() {
             let peerstate = peerstate.as_mut().unwrap();
 
             // if we're here, we know the gossip key is verified:
@@ -1662,27 +1693,29 @@ 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 !is_verified
+            if 0 == is_verified
                 || peerstate.verified_key_fingerprint != peerstate.public_key_fingerprint
                     && peerstate.verified_key_fingerprint != peerstate.gossip_key_fingerprint
             {
-                info!(context, "{} has verified {}.", contact.get_addr(), to_addr,);
+                info!(context, "{} has verfied {}.", 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).unwrap();
-                    is_verified = true;
+                    peerstate.save_to_db(&context.sql, false);
+                    is_verified = 1;
                 }
             }
         }
-        if !is_verified {
-            bail!(
+        if 0 == is_verified {
+            verify_fail(format!(
                 "{} is not a member of this verified group",
-                to_addr.to_string()
-            );
+                to_addr
+            ));
+            return 0;
         }
     }
-    Ok(())
+
+    1
 }
 
 fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {

src/dc_strencode.rs

@@ -1,4 +1,3 @@
-use itertools::Itertools;
 use std::borrow::Cow;
 use std::ffi::CString;
 use std::ptr;
@@ -6,6 +5,7 @@ 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,49 +25,195 @@ use crate::dc_tools::*;
  * @return Returns the encoded string which must be free()'d when no longed needed.
  *     On errors, NULL is returned.
  */
-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()));
+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;
     }
-
-    result
-}
-
-fn must_encode(byte: u8) -> bool {
-    static SPECIALS: &[u8] = b",:!\"#$@[\\]^`{|}~=?_";
-
-    SPECIALS.into_iter().any(|b| *b == byte)
-}
-
-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;
+    loop {
+        if !ok_to_continue {
+            if !mmapstr.is_null() {
+                mmap_string_free(mmapstr);
+            }
+            break;
         } else {
-            result.push(byte as _);
+            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;
+            }
         }
     }
 
-    if encoded {
-        result = format!("=?utf-8?Q?{}?=", &result);
+    let s = to_string(ret_str);
+    free(ret_str.cast());
+    s
+}
+
+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;
     }
-    result
+
+    // 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
+}
+
+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)
+    }
+    *pto_be_quoted = to_be_quoted(begin, cur.wrapping_offset_from(begin) as libc::size_t);
+    *pend = cur;
 }
 
 /* ******************************************************************************
  * 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();
@@ -173,6 +319,15 @@ 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::*;
@@ -274,6 +429,18 @@ 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! {
@@ -289,13 +456,5 @@ 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

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

src/error.rs

@@ -26,10 +26,6 @@ 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>;
@@ -40,12 +36,6 @@ 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)
@@ -70,12 +60,6 @@ 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 imex().
+    /// Inform about the import/export progress started by dc_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 imex().
-    /// This event may be sent multiple times by a single call to imex().
+    /// 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 typical purpose for a handler of this event may be to make the file public to some system
     /// services.

src/imap.rs

@@ -110,8 +110,6 @@ 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();
@@ -955,7 +953,14 @@ impl Imap {
             if !is_deleted && msg.body().is_some() {
                 let body = msg.body().unwrap();
                 unsafe {
-                    dc_receive_imf(context, &body, folder.as_ref(), server_uid, flags as u32);
+                    dc_receive_imf(
+                        context,
+                        body.as_ptr() as *const libc::c_char,
+                        body.len(),
+                        folder.as_ref(),
+                        server_uid,
+                        flags as u32,
+                    );
                 }
             }
         }

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 job_do_DC_JOB_IMEX_IMAP(context, &job) {
+                Action::ImexImap => match dc_job_do_DC_JOB_IMEX_IMAP(context, &job) {
                     Ok(()) => {}
                     Err(err) => {
                         error!(context, "{}", err);

src/key.rs

@@ -2,6 +2,7 @@ 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};
@@ -253,14 +254,14 @@ pub fn dc_key_save_self_keypair(
     public_key: &Key,
     private_key: &Key,
     addr: impl AsRef<str>,
-    is_default: bool,
+    is_default: libc::c_int,
     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 as i32, public_key.to_bytes(), private_key.to_bytes(), time()],
+        params![addr.as_ref(), is_default, 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/peerstate.rs

@@ -7,7 +7,6 @@ use crate::aheader::*;
 use crate::chat::*;
 use crate::constants::*;
 use crate::context::Context;
-use crate::error::*;
 use crate::key::*;
 use crate::sql::{self, Sql};
 
@@ -23,7 +22,7 @@ pub struct Peerstate<'a> {
     pub gossip_key: Option<Key>,
     pub gossip_timestamp: i64,
     pub gossip_key_fingerprint: Option<String>,
-    pub verified_key: Option<Key>,
+    verified_key: VerifiedKey,
     pub verified_key_fingerprint: Option<String>,
     pub to_save: Option<ToSave>,
     pub degrade_event: Option<DegradeEvent>,
@@ -85,6 +84,32 @@ pub enum DegradeEvent {
     FingerprintChanged = 0x02,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum VerifiedKey {
+    Gossip,
+    Public,
+    None,
+}
+
+impl Default for VerifiedKey {
+    fn default() -> Self {
+        VerifiedKey::None
+    }
+}
+
+impl VerifiedKey {
+    pub fn is_none(&self) -> bool {
+        match self {
+            VerifiedKey::None => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_some(&self) -> bool {
+        !self.is_none()
+    }
+}
+
 impl<'a> Peerstate<'a> {
     pub fn new(context: &'a Context) -> Self {
         Peerstate {
@@ -98,13 +123,21 @@ impl<'a> Peerstate<'a> {
             gossip_key: None,
             gossip_key_fingerprint: None,
             gossip_timestamp: 0,
-            verified_key: None,
+            verified_key: Default::default(),
             verified_key_fingerprint: None,
             to_save: None,
             degrade_event: None,
         }
     }
 
+    pub fn verified_key(&self) -> Option<&Key> {
+        match self.verified_key {
+            VerifiedKey::Public => self.public_key.as_ref(),
+            VerifiedKey::Gossip => self.gossip_key.as_ref(),
+            VerifiedKey::None => None,
+        }
+    }
+
     pub fn from_header(context: &'a Context, header: &Aheader, message_time: i64) -> Self {
         let mut res = Self::new(context);
 
@@ -208,11 +241,19 @@ impl<'a> Peerstate<'a> {
                     .get(6)
                     .ok()
                     .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
-                res.verified_key = row
+                let vk = row
                     .get(9)
                     .ok()
                     .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
 
+                res.verified_key = if vk == res.gossip_key && res.gossip_key.is_some() {
+                    VerifiedKey::Gossip
+                } else if vk == res.public_key {
+                    VerifiedKey::Public
+                } else {
+                    VerifiedKey::None
+                };
+
                 Ok(res)
             })
             .ok()
@@ -332,7 +373,7 @@ impl<'a> Peerstate<'a> {
         }
 
         if 0 != min_verified {
-            return self.verified_key.as_ref();
+            return self.verified_key();
         }
         if self.public_key.is_some() {
             return self.public_key.as_ref();
@@ -349,7 +390,7 @@ impl<'a> Peerstate<'a> {
                 && self.public_key_fingerprint.as_ref().unwrap() == fingerprint
             {
                 self.to_save = Some(ToSave::All);
-                self.verified_key = self.public_key.clone();
+                self.verified_key = VerifiedKey::Public;
                 self.verified_key_fingerprint = self.public_key_fingerprint.clone();
                 success = true;
             }
@@ -358,7 +399,7 @@ impl<'a> Peerstate<'a> {
                 && self.gossip_key_fingerprint.as_ref().unwrap() == fingerprint
             {
                 self.to_save = Some(ToSave::All);
-                self.verified_key = self.gossip_key.clone();
+                self.verified_key = VerifiedKey::Gossip;
                 self.verified_key_fingerprint = self.gossip_key_fingerprint.clone();
                 success = true;
             }
@@ -367,19 +408,28 @@ impl<'a> Peerstate<'a> {
         success
     }
 
-    pub fn save_to_db(&self, sql: &Sql, create: bool) -> Result<()> {
-        ensure!(!self.addr.is_none(), "self.addr is not configured");
+    pub fn save_to_db(&self, sql: &Sql, create: bool) -> bool {
+        let mut success = false;
+
+        if self.addr.is_none() {
+            return success;
+        }
+
         if create {
-            sql::execute(
+            if 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 {
-            sql::execute(
+            success = sql::execute(
                 self.context,
                 sql,
 		"UPDATE acpeerstates \
@@ -396,13 +446,14 @@ impl<'a> Peerstate<'a> {
                     self.gossip_key.as_ref().map(|k| k.to_bytes()),
                     &self.public_key_fingerprint,
                     &self.gossip_key_fingerprint,
-                    self.verified_key.as_ref().map(|k| k.to_bytes()),
+                    self.verified_key().map(|k| k.to_bytes()),
                     &self.verified_key_fingerprint,
                     &self.addr,
                 ],
-            )?
+            ).is_ok();
+            assert_eq!(success, true);
         } else if self.to_save == Some(ToSave::Timestamps) {
-            sql::execute(
+            success = sql::execute(
                 self.context,
                 sql,
                 "UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? \
@@ -413,14 +464,15 @@ 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);
         }
 
-        Ok(())
+        success
     }
 
     pub fn has_verified_key(&self, fingerprints: &HashSet<String>) -> bool {
@@ -464,16 +516,13 @@ mod tests {
             gossip_key: Some(pub_key.clone()),
             gossip_timestamp: 12,
             gossip_key_fingerprint: Some(pub_key.fingerprint()),
-            verified_key: Some(pub_key.clone()),
+            verified_key: VerifiedKey::Gossip,
             verified_key_fingerprint: Some(pub_key.fingerprint()),
             to_save: Some(ToSave::All),
             degrade_event: None,
         };
 
-        assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
-            "failed to save to db"
-        );
+        assert!(peerstate.save_to_db(&ctx.ctx.sql, true), "failed to save");
 
         let peerstate_new = Peerstate::from_addr(&ctx.ctx, &ctx.ctx.sql, addr.into())
             .expect("failed to load peerstate from db");
@@ -509,16 +558,13 @@ mod tests {
             gossip_key: None,
             gossip_timestamp: 12,
             gossip_key_fingerprint: None,
-            verified_key: None,
+            verified_key: VerifiedKey::None,
             verified_key_fingerprint: None,
             to_save: Some(ToSave::All),
             degrade_event: None,
         };
 
-        assert!(
-            peerstate.save_to_db(&ctx.ctx.sql, true).is_ok(),
-            "failed to save"
-        );
+        assert!(peerstate.save_to_db(&ctx.ctx.sql, true), "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

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

src/smtp.rs

@@ -70,9 +70,8 @@ impl Smtp {
         let port = lp.send_port as u16;
 
         let tls = native_tls::TlsConnector::builder()
-            // see also: https://github.com/deltachat/deltachat-core-rust/issues/203
+            // FIXME: unfortunately this is needed to make things work on macos + testrun.org
             .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).unwrap();
+                            peerstate.save_to_db(sql, false);
                         }
                     }
                     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, true, &ctx.sql);
+    let saved = key::dc_key_save_self_keypair(&ctx, &public, &private, &addr, 1, &ctx.sql);
     assert_eq!(saved, true, "Failed to save Alice's key");
     addr
 }

src/wrapmime.rs

@@ -1,12 +1,10 @@
 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::*;
@@ -27,135 +25,6 @@ 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() {
-            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

@@ -1,125 +0,0 @@
------BEGIN PGP MESSAGE-----
-Passphrase-Format: numeric9x4
-Passphrase-Begin: 17
-
-wy4ECQMI0jNRBQfVKHVg1+a2Yihd6JAjR9H0kk3oDVeX7nc4Oi+IjEtonUJt
-PQpO0tPWASWYuYvjZSuTz9r1yZYV+y4mu9bu9NEQoRlWg2wnbjoUoKk4emFF
-FweUj84iI6VWTCSRyMu5d5JS1RfOdX4CG/muLAegyIHezqYOEC0Z3b9Ci9rd
-DiSgqqN+/LDkUR/vr7L2CSLN5suBP9Hsz75AtaV8DJ2DYDywYX89yH1CfL1O
-WohyrJPdmGJZfdvQX0LI9mzN7MH0W6vUJeCaUpujc+UkLiOM6TDB74rmYF+V
-Z7K9BXbaN4V6dyxVZfgpXUoZlaNpvqPJXuLHJ68umkuIgIyQvzmMj3mFgZ8s
-akCt6Cf3o5O9n2PJvX89vuNnDGJrO5booEqGaBJfwUk0Rwb0gWsm5U0gceUz
-dce8KZK15CzX+bNv5OC+8jjjBw7mBHVt+2q8LI+G9fEy9NIREkp5/v2ZRN0G
-R6lpZwW+8TkMvJnriQeABqDpxsJVT6ENYAhkPG3AZCr/whGBU3EbDzPexXkz
-qt8Pdu5DrazLSFtjpjkekrjCh43vHjGl8IOiWxKQx0VfBkHJ7O9CsHmb0r1o
-F++fMh0bH1/aewmlg5wd0ixwZoP1o79he8Q4kfATZAjvB1xSLyMma+jxW5uu
-U3wYUOsUmYmzo46/QzizFCUpaTJ4ZQZY1/4sflidsl/XgZ0fD1NCrdkWBNA1
-0tQF949pEAeA4hSfHfQDNKAY8A7fk8lZblqWPkyu/0x8eV537QOhs89ZvhSB
-V87KEAwxWt60+Eolf8PvvkvB/AKlfWq4MYShgyldwwCfkED3rv2mvTsdqfvW
-WvqZNo4eRkJrnv9Be3LaXoFyY6a3z+ObBIkKI+u5azGJYge97O4E2DrUEKdQ
-cScq5upzXity0E+Yhm964jzBzxnA52S4RoXzkjTxH+AHjQ5+MHQxmRfMd2ly
-7skM106weVOR0JgOdkvfiOFDTHZLIVCzVyYVlOUJYYwPhmM1426zbegHNkaM
-M2WgvjMp5G+X9qfDWKecntQJTziyDFZKfd1UrUCPHrvl1Ac9cuqgcCXLtdUS
-jI+e1Y9fXvgyvHiMX0ztSz1yfvnRt34508G9j68fEQFQR/VIepULB5/SqKbq
-p2flgJL48kY32hEw2GRPri64Tv3vMPIWa//zvQDhQPmcd3S4TqnTIIKUoTAO
-NUo6GS9UAX12fdSFPZINcAkNIaB69+iwGyuJE4FLHKVkqNnNmDwF3fl0Oczo
-hbboWzA3GlpR2Ri6kfe0SocfGR0CHT5ZmqI6es8hWx+RN8hpXcsRxGS0BMi2
-mcJ7fPY+bKastnEeatP+b0XN/eaJAPZPZSF8PuPeQ0Uc735fylPrrgtWK9Gp
-Wq0DPaWV/+O94OB/JvWT5wq7d/EEVbTck5FPl4gdv3HHpaaQ6/8G89wVMEXA
-GUxB8WuvNeHAtQ7qXF7TkaZvUpF0rb1aV88uABOOPpsfAyWJo/PExCZacg8R
-GOQYI6inV5HcGUw06yDSqArHZmONveqjbDBApenearcskv6Uz7q+Bp60GGSA
-lvU3C3RyP/OUc1azOp72MIe0+JvP8S5DN9/Ltc/5ZyZHOjLoG+npIXnThYwV
-0kkrlsi/7loCzvhcWOac1vrSaGVCfifkYf+LUFQFrFVbxKLOQ6vTsYZWM0yM
-QsMMywW5A6CdROT5UB0UKRh/S1cwCwrN5UFTRt2UpDF3wSBAcChsHyy90RAL
-Xd4+ZIyf29GIFuwwQyzGBWnXQ2ytU4kg/D5XSqJbJJTya386UuyQpnFjI19R
-uuD0mvEfFvojCKDJDWguUNtWsHSg01NXDSrY26BhlOkMpUrzPfX5r0FQpgDS
-zOdY9SIG+y9MKG+4nwmYnFM6V5NxVL+6XZ7BQTvlLIcIIu+BujVNWteDnWNZ
-T1UukCGmFd8sNZpCc3wu4o/gLDQxih/545tWMf0dmeUfYhKcjSX9uucMRZHT
-1N0FINw04fDdp2LccL+WCGatFGnkZVPw3asid4d1od9RG9DbNRBJEp/QeNhc
-/peJCPLGYlA1NjTEq+MVB+DHdGNOuy//be3KhedBr6x4VVaDzL6jyHu/a7PR
-BWRVtI1CIVDxyrEXucHdGQoEm7p+0G2zouOe/oxbPFoEYrjaI+0e/FN3u/Y3
-aG0dlYWbxeHMqTh2F3lB/CFALReeGqqN6PwRyePWKaVctZYb6ydf9JVl6q1/
-aV9C5rf9eFGqqA+OIx/+XuAG1w0rwlznvtajHzCoUeA4QfbmuOV/t5drWN2N
-PCk2mJlcSmd7lx53rnOIgme1hggchjezc4TisL4PvSLxjJ7DxzktD2jv2I/Q
-OlSxTUaXnGfIVedsI0WjFomz5w9tZjC0B5O5TpSRRz6gfpe/OC3kV7qs1YCS
-lJTTxj1mTs6wqt0WjKkN/Ke0Cm5r7NQ79szDNlcC0AViEOQb3U1R88nNdiVx
-ymKT5Dl+yM6acv53lNX6O5BH+mpP2/pCpi3x+kYFyr4cUsNgVVGlhmkPWctZ
-trHvO7wcLrAsrLNqRxt1G3DLjQt9VY+w5qOPJv6s9qd5JBL/qtH5zqIXiXlM
-IWI9LLwHFFXqjk/f6G4LyOeHB9AqccGQ4IztgzTKmYEmFWVIpTO4UN6+E7yQ
-gtcYSIUEJo824ht5rL+ODqmCSAWsWIomEoTPvgn9QqO0YRwAEMpsFtE17klS
-qjbYyV7Y5A0jpCvqbnGmZPqCgzjjN/p5VKSNjSdM0vdwBRgpXlyooXg/EGoJ
-ZTZH8nLSuYMMu7AK8c7DKJ1AocTNYHRe9xFV8RzEiIm3zaezxa0r+Fo3nuTX
-UR9DOH0EHaDLrFQcfS5y1iRxY9CHg0N2ECaUzr/H7jck9mLZ7v9xisj3QDuv
-i0xQbC4BTxMEBGTK8fOcjHHOABOyhqotOreERqwOV2c1OOGUQE8QK18zJCUd
-BTmQZ709ttASD7VWK4TraOGczZXkZsKdZko5T6+6EkFy9H+gwENLUG9zk0x9
-2G5zicDr6PDoAGDuoB3B3VA8ertXTX7zEz30N6m+tcAtPWka0owokLy3f0o7
-ZdytBPkly8foTMWKF2vsJ8K4Xdn/57jJ2qFku32xmtiPIoa6s8wINO06AVB0
-0/AuttvxcPr+ycE+9wRZHx6JBujAqOZztU3zu8WZMaqVKb7gnmkWPiL+1XFp
-2+mr0AghScIvjzTDEjigDtLydURJrW01wXjaR0ByBT4z8ZjaNmQAxIPOIRFC
-bD0mviaoX61qgQLmSc6mzVlzzNZRCKtSvvGEK5NJ6CB6g2EeFau8+w0Zd+vv
-/iv6Img3pUBgvpMaIsxRXvGZwmo2R0tztJt+CqHRvyTWjQL+CjIAWyoHEdVH
-k7ne/q9zo3iIMsQUO7tVYtgURpRYc2OM1IVQtrgbmbYGEdOrhMjaWULg9C7o
-6oDM0EFlCAId3P8ykXQNMluFKlf9il5nr19B/qf/wh6C7DFLOmnjTWDXrEiP
-6wFEWTeUWLchGlbpiJFEu05MWPIRoRd3BHQvVpzLLgeBdxMVW7D6WCK+KJxI
-W1rOKhhLVvKU3BrFgr12A4uQm+6w1j33Feh68Y0JB7GLDBBGe11QtLCD6kz5
-RzFl+GbgiwpHi3nlCc5yiNwyPq/JRxU3GRb62YJcsSQBg+CD3Mk5FGiDcuvp
-kZXOcTE2FAnUDigjEs+oH2qkhD4/5CiHkrfFJTzv+wqw+jwxPor2jkZH2akN
-6PssXQYupXJE3NmcyaYT+b5E6qbkIyQj7CknkiqmrqrmxkOQxA+Ab2Vy9zrW
-u0+Wvf+C+SebWTo3qfJZQ3KcASZHa5AGoSHetWzH2fNLIHfULXac/T++1DWE
-nbeNvhXiFmAJ+BRsZj9p6RcnSamk4bjAbX1lg2G3Sq6MiA1fIRSMlSjuDLrQ
-8xfVFrg7gfBIIQPErJWv2GdAsz76sLxuSXQLKYpFnozvMT7xRs84+iRNWWh9
-SNibbEjlh0DcJlKw49Eis/bN22sDQWy4awHuRvvQetk/QCgp54epuqWnbxoE
-XZDgGBBkMc3or+6Cxr3q9x7J/oHLvPb+Q5yVP9fyz6ZiSVWluMefA9smjJ/A
-KMD84s7uO/8/4yug+swXGrcBjHSddTcy05vm+7X6o9IEZKZb5tz7VqAfEcuk
-QNPUWCMudhzxSNr4+yVXRVpcjsjKtplJcXC5aIuJwq3C5OdysCGqXWjLuUu1
-OFSoPvTsYC2VxYdFUcczeHEFTxXoXz3I0TyLPyxUNsJiKpUGt/SXmV/IyAx+
-h6pZ2OUXspC9d78DdiHZtItPjEGiIb678ZyMxWPE59XQd/ad92mlPHU8InXD
-yTq6otZ7LwAOLGbDR9bqN7oX8PCHRwuu30hk2b4+WkZn/WLd2KCPddQswZJg
-Qgi5ajUaFhZvxF5YNTqIzzYVh7Y8fFMfzH9AO+SJqy+0ECX0GwtHHeVsXYNb
-P/NO/ma4MI8301JyipPmdtzvvt9NOD/PJcnZH2KmDquARXMO/vKbn3rNUXog
-pTFqqyNTr4L5FK86QPEoE4hDy9ItHGlEuiNVD+5suGVGUgYfV7AvZU46EeqO
-rfFj8wNSX1aK/pIwWmh1EkygPSxomWRUANLX1jO6zX9wk2X80Xn9q/8jot1k
-Vl54OOd7cvGls2wKkEZi5h3p6KKZHJ+WIDBQupeJbuma1GK8wAiwjDH59Y0X
-wXHAk7XA+t4u0dgRpZbUUMqQmvEvfJaCr4qMlpuGdEYbbpIMUB1qCfYU9taL
-zbepMIT+XYD5mTyytZhR+zrsfpt1EzbrhuabqPioySoIS/1+bWfxvndq16r0
-AdNxR5LiVSVh8QJr3B/HJhVghgSVrrynniG3E94abNWL/GNxPS/dTHSf8ass
-vbv7+uznADzHsMiG/ZlLAEkQJ9j0ENJvHmnayeVFIXDV6jPCcQJ+rURDgl7z
-/qTLfe3o3zBMG78LcB+xDNXTQrK5Z0LX7h17hLSElpiUghFa9nviCsT0nkcr
-nz302P4IOFwJuYMMCEfW+ywTn+CHpKjLHWkZSZ4q6LzNTbbgXZn/vh7njNf0
-QHaHmaMNxnDhUw/Bl13uM52qtsfEYK07SEhLFlJbAk0G7q+OabK8dJxCRwS3
-X9k4juzLUYhX8XBovg9G3YEVckb6iM8/LF/yvNXbUsPrdhYU9lPA63xD0Pgb
-zthZCLIlnF+lS6e41WJv3n1dc4dFWD7F5tmt/7uwLC6oUGYsccSzY+bUkYhL
-dp7tlQRd5AG/Xz8XilORk8cUjvi6uZss5LyQpKvGSU+77C8ZV/oS62BdS5TE
-osBTrO2/9FGzQtHT+8DJSTPPgR6rcQUWLPemiG09ACKfRQ/g3b9Qj0upOcKL
-6dti0lq7Aorc39vV18DPMFBOwzchUEBlBFyuSa4AoD30tsoilAC3qbzBwu3z
-QLjmst76HEcWDkxgDAhlBz6/XgiVZsCivn7ygigmc2+hNEzIdDsKKfM9bkoe
-3uJzmmsv8Bh5ZEtfGoGNmu/zA7tgvTOCBeotYeHr2O6pLmYb3hK+E/qCBl14
-8pK4qYrjAlF+ZMq9BzXcaz5mRfKVfAQtghHOaNqopBczSE1bjFF6HaNhIaGa
-N8YdabNQG7mLI/fgBxJfkPl6HdIhEpctp4RURbSFhW+wn0o85VyHM6a+6Vgj
-NrYmhxPZ6N1KN0Qy76aNiw7nAToRRcOv87uZnkDIeVH8mP/0hldyiy/Y97cG
-QgOeQHOG27QW57nHhqLRqvf0zzQZekuXWFbqajpaabEcdGXyiUpJ8/ZopBPM
-AJwfkyA2LkV946IA4JV6sPnu9pYzpXQ4vdQKJ6DoDUyRTQmgmfSFGtfHAozY
-V9k0iQeetSkYYtOagTrg3t92v7M00o/NJW/rKX4jj2djD8wtBovOcv4kxg4Z
-o58Iv94ROim48XfyesvSYKN1xqqbXH4sfE6b4b9pLUxQVOmWANLK9MK8D+Ci
-IvrGbz5U5bZP6vlNbe9bYzjvWTPjaMrjXknRTBcikavqOfDTSIVFtT4qvhvK
-42PpOrm0qdiLwExGKQ9FfEfYZRgEcYRGg7rH3oNz6ZNOEXppF3tCl9yVOlFb
-ygdIeT3Z3HeOQbAsi8jK7o16DSXL7ZOpFq9Bv9yzusrF7Eht/fSEpAVUO3D1
-IuqjZcsQRhMtIvnF0oFujFtooJx9x3dj/RarvEGX/NzwATZkgJ+yWs2etruA
-EzMQqED4j7Lb790zEWnt+nuHdCdlPnNy8RG5u5X62p3h5KqUbg9HfmIuuESi
-hwr6dKsVQGc5XUB5KTt0dtjWlK5iaetDsZFuF5+aE0Xa6PmiQ2e7ZPFyxXmO
-T/PSHzobx0qClKCu+tSWA1HDSL08IeoGZEyyhoaxyn5D9r1Mqg101v/iu59r
-lRRs+plAhbuq5aQA3WKtF1N6Zb5+AVRpNUyrxyHoH36ddR4/n7lnIld3STGD
-RqZLrOuKHS3dCNW2Pt15lU+loYsWFZwC6T/tAbvwhax+XaBMiKQSDFmG9sBw
-TiM1JWXhq2IsjXBvCl6k2AKWLQOvc/Hin+oYs4d7M9mi0vdoEOAMadU/+Pqn
-uZzP941mOUV5UeTCCbjpyfI7qtIi3TH1cQmC2kG2HrvQYuM6Momp//JusH1+
-9eHgFo25HbitcKJ1sAqxsnYIW5/jIVyIJC7tatxmNfFQQ/LUb2cT+Jowwsf4
-bbPinA9S6aQFy9k3vk07V2ouYl+cpMMXmNAUrboFRLxw7QDapWYMKdmnbU5O
-HZuDz3iyrm0lMPsRtt/f5WUhZYY4vXT5/dj+8P6Pr5fdc4S84i5qEzf7bX/I
-Sc6fpISdYBscfHdv6uXsEVtVPKEuQVYwhyc4kkwVKjZBaqsgjAA7VEhQXzO3
-rC7di4UhabWQCQTG1GYZyrj4bm6dg/32uVxMoLS5kuSpi3nMz5JmQahLqRxh
-argg13K2/MJ7w2AI23gCvO5bEmD1ZXIi1aGYdZfu7+KqrTumYxj0KgIesgU0
-6ekmPh4Zu5lIyKopa89nfQVj3uKbwr9LLHegfzeMhvI5WQWghKcNcXEvJwSA
-vEik5aXm2qSKXT+ijXBy5MuNeICoGaQ5WA0OJ30Oh5dN0XpLtFUWHZKThJvR
-mngm1QCMMw2v/j8=
-=9sJE
------END PGP MESSAGE-----