don't run fuzzy tests during debug

.gitignore

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

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()");
@@ -275,11 +275,11 @@ pub unsafe extern "C" fn dc_is_open(context: *mut dc_context_t) -> libc::c_int {
         eprintln!("ignoring careless call to dc_is_open()");
         return 0;
     }
-    let ffi_context = &*context;
+    let ffi_context = &mut *context;
     let inner_guard = ffi_context.inner.read().unwrap();
     match *inner_guard {
-        Some(_) => 1,
-        None => 0,
+        Some(_) => 0,
+        None => 1,
     }
 }
 
@@ -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);
-        }
-        _ => {}
-    };
-}
-pub 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"

python/src/deltachat/account.py

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

python/tests/test_lowlevel.py

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

spec.md

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

src/configure/auto_outlook.rs

@@ -21,6 +21,7 @@ struct outlk_autodiscover_t<'a> {
     pub out_smtp_set: libc::c_int,
     pub tag_config: libc::c_int,
     pub config: [*mut libc::c_char; 6],
+    pub redirect: *mut libc::c_char,
 }
 
 pub unsafe fn outlk_autodiscover(
@@ -37,6 +38,7 @@ pub unsafe fn outlk_autodiscover(
         out_smtp_set: 0,
         tag_config: 0,
         config: [ptr::null_mut(); 6],
+        redirect: ptr::null_mut(),
     };
     let ok_to_continue;
     let mut i = 0;

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/context.rs

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

src/dc_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
@@ -129,15 +98,14 @@ pub fn initiate_key_transfer(context: &Context) -> Result<String> {
                 .unwrap()
                 .shall_stop_ongoing
             {
-                let setup_file_name = context.new_blob_file(
-                    "autocrypt-setup-message.html",
-                    setup_file_content.as_bytes(),
-                )?;
-                {
+                let setup_file_name =
+                    dc_get_fine_path_filename(context, "$BLOBDIR", "autocrypt-setup-message.html");
+                if dc_write_file(context, &setup_file_name, setup_file_content.as_bytes()) {
                     if let Ok(chat_id) = chat::create_by_contact_id(context, 1) {
                         msg = Message::default();
                         msg.type_0 = Viewtype::File;
-                        msg.param.set(Param::File, setup_file_name);
+                        msg.param
+                            .set(Param::File, setup_file_name.to_string_lossy());
 
                         msg.param
                             .set(Param::MimeType, "application/autocrypt-setup");
@@ -181,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."
@@ -237,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();
@@ -245,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);
@@ -274,14 +242,16 @@ 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));
+            let armored_key: String;
+            unsafe {
+                let sc = dc_decrypt_setup_file(context, norm_sc.as_ptr(), buf.as_ptr().cast());
+                ensure!(!sc.is_null(), "bad setup code");
+                armored_key = to_string(sc);
+                free(sc as *mut libc::c_void);
             }
-
+            set_self_key(context, &armored_key, true, true)?;
             Ok(())
         } else {
             bail!("Cannot read Autocrypt Setup Message file.");
@@ -351,7 +321,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!");
@@ -359,56 +329,66 @@ fn set_self_key(
     Ok(())
 }
 
-fn decrypt_setup_file(
-    _context: &Context,
-    passphrase: impl AsRef<str>,
-    filecontent: &mut [u8],
-) -> Result<String> {
+pub unsafe fn dc_decrypt_setup_file(
+    context: &Context,
+    passphrase: *const libc::c_char,
+    filecontent: *const libc::c_char,
+) -> *mut libc::c_char {
+    let fc_buf: *mut libc::c_char;
     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,
-        )
-    };
-
-    if !split_result || fc_headerline != "-----BEGIN PGP MESSAGE-----" || fc_base64.is_null() {
-        bail!("Invalid armored data");
+    let mut payload: *mut libc::c_char = ptr::null_mut();
+    fc_buf = dc_strdup(filecontent);
+    if dc_split_armored_data(
+        fc_buf,
+        &mut fc_headerline,
+        ptr::null_mut(),
+        ptr::null_mut(),
+        &mut fc_base64,
+    ) && fc_headerline == "-----BEGIN PGP MESSAGE-----"
+        && !fc_base64.is_null()
+    {
+        /* convert base64 to binary */
+        /*must be freed using mmap_string_unref()*/
+        if !(mailmime_base64_body_parse(
+            fc_base64,
+            strlen(fc_base64),
+            &mut indx,
+            &mut binary,
+            &mut binary_bytes,
+        ) != MAILIMF_NO_ERROR as libc::c_int
+            || binary.is_null()
+            || binary_bytes == 0)
+        {
+            /* decrypt symmetrically */
+            match dc_pgp_symm_decrypt(
+                as_str(passphrase),
+                std::slice::from_raw_parts(binary as *const u8, binary_bytes),
+            ) {
+                Ok(plain) => {
+                    let payload_c = CString::new(plain).unwrap();
+                    payload = strdup(payload_c.as_ptr());
+                }
+                Err(err) => {
+                    error!(context, "Failed to decrypt message: {:?}", err);
+                }
+            }
+        }
     }
 
-    // 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' {
@@ -422,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.");
@@ -432,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.");
@@ -443,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);
@@ -465,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,
@@ -541,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(),
                 );
             }
@@ -568,70 +552,73 @@ 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;
     // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
-    // FIXME: we should write to a temporary file first and rename it on success. this would guarantee the backup is complete.
-    // let dest_path_filename = dc_get_next_backup_file(context, dir, res);
+    // FIXME: we should write to a temporary file first and rename it on success. this would guarantee the backup is complete. however, currently it is not clear it the import exists in the long run (may be replaced by a restore-from-imap)
     let now = time();
-    let dest_path_filename = dc_get_next_backup_path(dir, now)?;
+    let res = chrono::NaiveDateTime::from_timestamp(now as i64, 0)
+        .format("delta-chat-%Y-%m-%d.bak")
+        .to_string();
+
+    let dest_path_filename = dc_get_fine_path_filename(context, dir, res);
 
     sql::housekeeping(context);
 
     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();
@@ -664,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;
@@ -675,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;
@@ -690,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);
     }
@@ -787,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-----")
@@ -898,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
@@ -924,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>"));
     }
@@ -935,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(), '-');
@@ -963,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,12 +5,14 @@ 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::*;
 use mmime::mailmime::disposition::*;
 use mmime::mailmime::types::*;
 use mmime::mailmime::*;
+use mmime::mmapstring::*;
 use mmime::other::*;
 
 use crate::constants::Viewtype;
@@ -19,12 +21,11 @@ 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::*;
 use crate::stock::StockMessage;
-use crate::wrapmime;
 
 #[derive(Debug)]
 pub struct MimeParser<'a> {
@@ -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,18 +113,14 @@ impl<'a> MimeParser<'a> {
         );
 
         if r == MAILIMF_NO_ERROR as libc::c_int && !self.mimeroot.is_null() {
-            let (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") {
                 if (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
                     let subj = (*(*field).fld_data.fld_subject).sbj_value;
 
-                    self.subject = as_opt_str(subj).map(dc_decode_header_words);
+                    self.subject = as_opt_str(subj).map(dc_decode_header_words_safe);
                 }
             }
 
@@ -287,12 +280,12 @@ impl<'a> MimeParser<'a> {
                         ) == MAILIMF_NO_ERROR as libc::c_int
                             && !mb_list.is_null()
                         {
-                            if let Some(dn_to_addr) = wrapmime::mailimf_find_first_addr(mb_list) {
+                            if let Some(dn_to_addr) = mailimf_find_first_addr(mb_list) {
                                 if let Some(from_field) = self.lookup_field("From") {
                                     if (*from_field).fld_type == MAILIMF_FIELD_FROM as libc::c_int
                                         && !(*from_field).fld_data.fld_from.is_null()
                                     {
-                                        let from_addr = wrapmime::mailimf_find_first_addr(
+                                        let from_addr = mailimf_find_first_addr(
                                             (*(*from_field).fld_data.fld_from).frm_mb_list,
                                         );
                                         if let Some(from_addr) = from_addr {
@@ -324,7 +317,6 @@ impl<'a> MimeParser<'a> {
             }
             self.parts.push(part_5);
         }
-        Ok(())
     }
 
     pub fn get_last_nonmeta(&mut self) -> Option<&mut Part> {
@@ -590,7 +582,7 @@ impl<'a> MimeParser<'a> {
             return false;
         }
 
-        let mut decoded_data = match wrapmime::mailmime_transfer_decode(mime) {
+        let mut decoded_data = match mailmime_transfer_decode(mime) {
             Ok(decoded_data) => decoded_data,
             Err(_) => {
                 // Note that it's now always an error - might be no data
@@ -704,7 +696,7 @@ impl<'a> MimeParser<'a> {
                                         // might be a wrongly encoded filename
                                         let s = to_string_lossy((*dsp_param).pa_data.pa_filename);
                                         // this is used only if the parts buffer stays empty
-                                        desired_filename = dc_decode_header_words(&s)
+                                        desired_filename = dc_decode_header_words_safe(&s)
                                     }
                                 }
                             }
@@ -776,40 +768,34 @@ impl<'a> MimeParser<'a> {
         decoded_data: &[u8],
         desired_filename: &str,
     ) {
-        /* write decoded data to new blob file */
-        let bpath = match self.context.new_blob_file(desired_filename, decoded_data) {
-            Ok(path) => path,
-            Err(err) => {
-                error!(
-                    self.context,
-                    "Could not add blob for mime part {}, error {}", desired_filename, err
-                );
-                return;
-            }
-        };
+        /* create a free file name to use */
+        let path_filename = dc_get_fine_path_filename(self.context, "$BLOBDIR", desired_filename);
 
-        let mut part = Part::default();
-        part.typ = msg_type;
-        part.mimetype = mime_type;
-        part.bytes = decoded_data.len() as libc::c_int;
-        part.param.set(Param::File, bpath);
-        if let Some(raw_mime) = raw_mime {
-            part.param.set(Param::MimeType, raw_mime);
-        }
-
-        if mime_type == DC_MIMETYPE_IMAGE {
-            if let Ok((width, height)) = dc_get_filemeta(decoded_data) {
-                part.param.set_int(Param::Width, width as i32);
-                part.param.set_int(Param::Height, height as i32);
+        /* copy data to file */
+        if dc_write_file(self.context, &path_filename, decoded_data) {
+            let mut part = Part::default();
+            part.typ = msg_type;
+            part.mimetype = mime_type;
+            part.bytes = decoded_data.len() as libc::c_int;
+            part.param.set(Param::File, path_filename.to_string_lossy());
+            if let Some(raw_mime) = raw_mime {
+                part.param.set(Param::MimeType, raw_mime);
             }
+
+            if mime_type == DC_MIMETYPE_IMAGE {
+                if let Ok((width, height)) = dc_get_filemeta(decoded_data) {
+                    part.param.set_int(Param::Width, width as i32);
+                    part.param.set_int(Param::Height, height as i32);
+                }
+            }
+            self.do_add_single_part(part);
         }
-        self.do_add_single_part(part);
     }
 
     fn do_add_single_part(&mut self, mut part: Part) {
-        if self.encrypted && self.signatures.len() > 0 {
+        if self.e2ee_helper.encrypted && self.e2ee_helper.signatures.len() > 0 {
             part.param.set_int(Param::GuranteeE2ee, 1);
-        } else if self.encrypted {
+        } else if self.e2ee_helper.encrypted {
             part.param.set_int(Param::ErroneousE2ee, 0x2);
         }
         self.parts.push(part);
@@ -838,7 +824,7 @@ impl<'a> MimeParser<'a> {
         let mut fld_from: *const mailimf_from = ptr::null();
 
         /* get From: and check there is exactly one sender */
-        let fld = wrapmime::mailimf_find_field(self.header_root, MAILIMF_FIELD_FROM as libc::c_int);
+        let fld = mailimf_find_field(self.header_root, MAILIMF_FIELD_FROM as libc::c_int);
         if !(fld.is_null()
             || {
                 fld_from = (*fld).fld_data.fld_from;
@@ -856,7 +842,7 @@ impl<'a> MimeParser<'a> {
 
             if !mb.is_null() {
                 let from_addr_norm = addr_normalize(as_str((*mb).mb_addr_spec));
-                let recipients = wrapmime::mailimf_get_recipients(self.header_root);
+                let recipients = mailimf_get_recipients(self.header_root);
                 if recipients.len() == 1 {
                     if recipients.contains(from_addr_norm) {
                         sender_equals_recipient = true;
@@ -903,6 +889,7 @@ impl<'a> Drop for MimeParser<'a> {
         if !self.mimeroot.is_null() {
             unsafe { mailmime_free(self.mimeroot) };
         }
+        unsafe { self.e2ee_helper.thanks() };
     }
 }
 
@@ -917,6 +904,22 @@ pub struct Part {
     pub param: Params,
 }
 
+pub fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> Option<String> {
+    if mb_list.is_null() {
+        return None;
+    }
+
+    for cur in unsafe { (*(*mb_list).mb_list).into_iter() } {
+        let mb = cur as *mut mailimf_mailbox;
+        if !mb.is_null() && !unsafe { (*mb).mb_addr_spec.is_null() } {
+            let addr = unsafe { as_str((*mb).mb_addr_spec) };
+            return Some(addr_normalize(addr).to_string());
+        }
+    }
+
+    None
+}
+
 unsafe fn hash_header(out: &mut HashMap<String, *mut mailimf_field>, in_0: *const mailimf_fields) {
     if in_0.is_null() {
         return;
@@ -1053,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,
@@ -1138,6 +1140,207 @@ pub unsafe fn mailmime_find_ct_parameter(
     ptr::null_mut()
 }
 
+pub unsafe fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, Error> {
+    ensure!(!mime.is_null(), "invalid inputs");
+
+    let mut mime_transfer_encoding = MAILMIME_MECHANISM_BINARY as libc::c_int;
+
+    let mime_data = (*mime).mm_data.mm_single;
+    if !(*mime).mm_mime_fields.is_null() {
+        for cur in (*(*(*mime).mm_mime_fields).fld_list).into_iter() {
+            let field = cur as *mut mailmime_field;
+
+            if !field.is_null()
+                && (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int
+                && !(*field).fld_data.fld_encoding.is_null()
+            {
+                mime_transfer_encoding = (*(*field).fld_data.fld_encoding).enc_type;
+                break;
+            }
+        }
+    }
+
+    if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int
+        || mime_transfer_encoding == MAILMIME_MECHANISM_8BIT as libc::c_int
+        || mime_transfer_encoding == MAILMIME_MECHANISM_BINARY as libc::c_int
+    {
+        let decoded_data = (*mime_data).dt_data.dt_text.dt_data;
+        let decoded_data_bytes = (*mime_data).dt_data.dt_text.dt_length;
+
+        if decoded_data.is_null() || decoded_data_bytes <= 0 {
+            bail!("No data to decode found");
+        } else {
+            let result = std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes);
+            return Ok(result.to_vec());
+        }
+    }
+
+    let mut current_index = 0;
+    let mut transfer_decoding_buffer = ptr::null_mut();
+    let mut decoded_data_bytes = 0;
+
+    let r = mailmime_part_parse(
+        (*mime_data).dt_data.dt_text.dt_data,
+        (*mime_data).dt_data.dt_text.dt_length,
+        &mut current_index,
+        mime_transfer_encoding,
+        &mut transfer_decoding_buffer,
+        &mut decoded_data_bytes,
+    );
+
+    if r == MAILIMF_NO_ERROR as libc::c_int
+        && !transfer_decoding_buffer.is_null()
+        && decoded_data_bytes > 0
+    {
+        let result =
+            std::slice::from_raw_parts(transfer_decoding_buffer as *const u8, decoded_data_bytes)
+                .to_vec();
+        mmap_string_unref(transfer_decoding_buffer);
+
+        return Ok(result);
+    }
+
+    Err(format_err!("Failed to to decode"))
+}
+
+pub 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 (*(*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();
+        // TODO match on enums /rtn
+        match (*fld).fld_type {
+            13 => {
+                fld_to = (*fld).fld_data.fld_to;
+                if !fld_to.is_null() {
+                    addr_list = (*fld_to).to_addr_list
+                }
+            }
+            14 => {
+                fld_cc = (*fld).fld_data.fld_cc;
+                if !fld_cc.is_null() {
+                    addr_list = (*fld_cc).cc_addr_list
+                }
+            }
+            _ => {}
+        }
+
+        if !addr_list.is_null() {
+            for cur2 in (*(*addr_list).ad_list).into_iter() {
+                let adr = cur2 as *mut mailimf_address;
+
+                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,
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    recipients
+}
+
+fn mailimf_get_recipients_add_addr(recipients: &mut HashSet<String>, mb: *mut mailimf_mailbox) {
+    if !mb.is_null() {
+        let addr_norm = addr_normalize(as_str(unsafe { (*mb).mb_addr_spec }));
+        recipients.insert(addr_norm.into());
+    }
+}
+
+/*the result is a pointer to mime, must not be freed*/
+pub unsafe fn mailimf_find_field(
+    header: *mut mailimf_fields,
+    wanted_fld_type: libc::c_int,
+) -> *mut mailimf_field {
+    if header.is_null() || (*header).fld_list.is_null() {
+        return ptr::null_mut();
+    }
+    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 (*field).fld_type == wanted_fld_type {
+                return field;
+            }
+        }
+        cur1 = if !cur1.is_null() {
+            (*cur1).next
+        } else {
+            ptr::null_mut()
+        }
+    }
+
+    ptr::null_mut()
+}
+
+/*the result is a pointer to mime, must not be freed*/
+pub unsafe fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
+    if mime.is_null() {
+        return ptr::null_mut();
+    }
+
+    match (*mime).mm_type as _ {
+        MAILMIME_MULTIPLE => {
+            for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
+                let header = mailmime_find_mailimf_fields(cur_data as *mut _);
+                if !header.is_null() {
+                    return header;
+                }
+            }
+        }
+        MAILMIME_MESSAGE => return (*mime).mm_data.mm_message.mm_fields,
+        _ => {}
+    }
+
+    ptr::null_mut()
+}
+
+pub unsafe fn mailimf_find_optional_field(
+    header: *mut mailimf_fields,
+    wanted_fld_name: *const libc::c_char,
+) -> *mut mailimf_optional_field {
+    if header.is_null() || (*header).fld_list.is_null() {
+        return ptr::null_mut();
+    }
+    for cur_data in (*(*header).fld_list).into_iter() {
+        let field: *mut mailimf_field = cur_data as *mut _;
+
+        if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
+            let optional_field: *mut mailimf_optional_field = (*field).fld_data.fld_optional_field;
+            if !optional_field.is_null()
+                && !(*optional_field).fld_name.is_null()
+                && !(*optional_field).fld_value.is_null()
+                && strcasecmp((*optional_field).fld_name, wanted_fld_name) == 0i32
+            {
+                return optional_field;
+            }
+        }
+    }
+
+    ptr::null_mut()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1153,13 +1356,14 @@ mod tests {
             let mut mime: *mut Mailmime = ptr::null_mut();
             let mut dummy = 0;
             let res = mailmime_parse(txt, strlen(txt), &mut dummy, &mut mime);
+
             assert_eq!(res, MAIL_NO_ERROR as libc::c_int);
             assert!(!mime.is_null());
 
-            let fields: *mut mailimf_fields = wrapmime::mailmime_find_mailimf_fields(mime);
+            let fields: *mut mailimf_fields = mailmime_find_mailimf_fields(mime);
             assert!(!fields.is_null());
 
-            let mut of_a: *mut mailimf_optional_field = wrapmime::mailimf_find_optional_field(
+            let mut of_a: *mut mailimf_optional_field = mailimf_find_optional_field(
                 fields,
                 b"fielda\x00" as *const u8 as *const libc::c_char,
             );
@@ -1179,7 +1383,7 @@ mod tests {
                 "ValueA",
             );
 
-            of_a = wrapmime::mailimf_find_optional_field(
+            of_a = mailimf_find_optional_field(
                 fields,
                 b"FIELDA\x00" as *const u8 as *const libc::c_char,
             );
@@ -1199,7 +1403,7 @@ mod tests {
                 "ValueA",
             );
 
-            let of_b: *mut mailimf_optional_field = wrapmime::mailimf_find_optional_field(
+            let of_b: *mut mailimf_optional_field = mailimf_find_optional_field(
                 fields,
                 b"FieldB\x00" as *const u8 as *const libc::c_char,
             );
@@ -1218,13 +1422,12 @@ mod tests {
     }
 
     #[test]
+    #[ignore]
     fn test_dc_mimeparser_crash() {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
         let mut mimeparser = MimeParser::new(&context.ctx);
-        unsafe {
-            mimeparser.parse(&raw[..]).unwrap();
-        };
+        unsafe { mimeparser.parse(&raw[..]) };
         assert_eq!(mimeparser.subject, None);
         assert_eq!(mimeparser.parts.len(), 1);
     }
@@ -1232,13 +1435,9 @@ mod tests {
     proptest! {
         #[test]
         fn test_dc_mailmime_parse_crash_fuzzy(data in "[!-~\t ]{2000,}") {
-            // this test doesn't exercise much of dc_mimeparser anymore
-            // because a missing From-field early aborts parsing
             let context = dummy_context();
             let mut mimeparser = MimeParser::new(&context.ctx);
-            unsafe {
-                assert!(mimeparser.parse(data.as_bytes()).is_err());
-            }
+            unsafe { mimeparser.parse(data.as_bytes()) };
         }
     }
 
@@ -1247,7 +1446,7 @@ mod tests {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/mail_with_message_id.txt");
         let mut mimeparser = MimeParser::new(&context.ctx);
-        unsafe { mimeparser.parse(&raw[..]).unwrap() };
+        unsafe { mimeparser.parse(&raw[..]) };
         assert_eq!(
             mimeparser.get_rfc724_mid(),
             Some("2dfdbde7@example.org".into())
@@ -1259,7 +1458,7 @@ mod tests {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
         let mut mimeparser = MimeParser::new(&context.ctx);
-        unsafe { mimeparser.parse(&raw[..]).unwrap() };
+        unsafe { mimeparser.parse(&raw[..]) };
         assert_eq!(mimeparser.get_rfc724_mid(), None);
     }
 
@@ -1267,9 +1466,9 @@ mod tests {
     fn test_mimeparser_with_context() {
         unsafe {
             let context = dummy_context();
-            let raw = b"From: hello\nContent-Type: multipart/mixed; boundary=\"==break==\";\nSubject: outer-subject\nX-Special-A: special-a\nFoo: Bar\nChat-Version: 0.0\n\n--==break==\nContent-Type: text/plain; protected-headers=\"v1\";\nSubject: inner-subject\nX-Special-B: special-b\nFoo: Xy\nChat-Version: 1.0\n\ntest1\n\n--==break==--\n\n\x00";
+            let raw = b"Content-Type: multipart/mixed; boundary=\"==break==\";\nSubject: outer-subject\nX-Special-A: special-a\nFoo: Bar\nChat-Version: 0.0\n\n--==break==\nContent-Type: text/plain; protected-headers=\"v1\";\nSubject: inner-subject\nX-Special-B: special-b\nFoo: Xy\nChat-Version: 1.0\n\ntest1\n\n--==break==--\n\n\x00";
             let mut mimeparser = MimeParser::new(&context.ctx);
-            mimeparser.parse(&raw[..]).unwrap();
+            mimeparser.parse(&raw[..]);
 
             assert_eq!(mimeparser.subject, Some("inner-subject".into()));
 

src/dc_receive_imf.rs

@@ -29,7 +29,6 @@ use crate::peerstate::*;
 use crate::securejoin::handle_securejoin_handshake;
 use crate::sql;
 use crate::stock::StockMessage;
-use crate::wrapmime;
 
 #[derive(Debug, PartialEq, Eq)]
 enum CreateEvent {
@@ -40,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,
@@ -61,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
@@ -205,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(),
@@ -292,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>,
@@ -611,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 \
@@ -682,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
                         },
@@ -698,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,
@@ -796,7 +803,7 @@ unsafe fn handle_reports(
                         b"disposition-notification\x00" as *const u8 as *const libc::c_char,
                     ) == 0
                 {
-                    if let Ok(report_body) = wrapmime::mailmime_transfer_decode(report_data) {
+                    if let Ok(report_body) = mailmime_transfer_decode(report_data) {
                         let mut report_parsed = std::ptr::null_mut();
                         let mut dummy = 0;
 
@@ -808,14 +815,13 @@ unsafe fn handle_reports(
                         ) == MAIL_NO_ERROR as libc::c_int
                             && !report_parsed.is_null()
                         {
-                            let report_fields =
-                                wrapmime::mailmime_find_mailimf_fields(report_parsed);
+                            let report_fields = mailmime_find_mailimf_fields(report_parsed);
                             if !report_fields.is_null() {
-                                let of_disposition = wrapmime::mailimf_find_optional_field(
+                                let of_disposition = mailimf_find_optional_field(
                                     report_fields,
                                     b"Disposition\x00" as *const u8 as *const libc::c_char,
                                 );
-                                let of_org_msgid = wrapmime::mailimf_find_optional_field(
+                                let of_org_msgid = mailimf_find_optional_field(
                                     report_fields,
                                     b"Original-Message-ID\x00" as *const u8 as *const libc::c_char,
                                 );
@@ -1078,7 +1084,7 @@ unsafe fn create_or_lookup_group(
     }
 
     if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Name") {
-        grpname = Some(dc_decode_header_words(&optional_field));
+        grpname = Some(dc_decode_header_words_safe(&optional_field));
     }
     if let Some(optional_field) = mime_parser.lookup_optional_field("Chat-Group-Member-Removed") {
         X_MrRemoveFromGrp = Some(optional_field);
@@ -1149,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 -
@@ -1186,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);
@@ -1600,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;
+            }
         }
     }
 
@@ -1644,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:
@@ -1664,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>) {
@@ -1967,7 +1998,7 @@ unsafe fn add_or_lookup_contact_by_addr(
     /* add addr_spec if missing, update otherwise */
     let mut display_name_dec = "".to_string();
     if !display_name_enc.is_null() {
-        let tmp = dc_decode_header_words(as_str(display_name_enc));
+        let tmp = as_str(dc_decode_header_words(display_name_enc));
         display_name_dec = normalize_name(&tmp);
     }
     /*can be NULL*/

src/dc_strencode.rs

@@ -1,11 +1,11 @@
-use itertools::Itertools;
 use std::borrow::Cow;
 use std::ffi::CString;
 use std::ptr;
 
 use charset::Charset;
-use libc::free;
+use libc::{free, strlen};
 use mmime::mailmime::decode::mailmime_encoded_phrase_parse;
+use mmime::mmapstring::*;
 use mmime::other::*;
 use percent_encoding::{percent_decode, utf8_percent_encode, AsciiSet, CONTROLS};
 
@@ -25,50 +25,217 @@ 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
  ******************************************************************************/
 
-pub(crate) fn dc_decode_header_words(input: &str) -> String {
+/* 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();
+    }
+    let mut out: *mut libc::c_char = ptr::null_mut();
+    let mut cur_token = 0;
+    let r: libc::c_int = mailmime_encoded_phrase_parse(
+        b"iso-8859-1\x00" as *const u8 as *const libc::c_char,
+        in_0,
+        strlen(in_0),
+        &mut cur_token,
+        b"utf-8\x00" as *const u8 as *const libc::c_char,
+        &mut out,
+    );
+    if r != MAILIMF_NO_ERROR as libc::c_int || out.is_null() {
+        out = dc_strdup(in_0)
+    }
+
+    out
+}
+
+pub fn dc_decode_header_words_safe(input: &str) -> String {
     static FROM_ENCODING: &[u8] = b"iso-8859-1\x00";
     static TO_ENCODING: &[u8] = b"utf-8\x00";
     let mut out = ptr::null_mut();
@@ -152,35 +319,73 @@ 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::*;
 
+    use libc::strcmp;
+    use std::ffi::CStr;
+
     #[test]
     fn test_dc_decode_header_words() {
-        assert_eq!(
-            dc_decode_header_words("=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?="),
-            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
-        );
-
-        assert_eq!(dc_decode_header_words("just ascii test"), "just ascii test");
-
-        assert_eq!(dc_encode_header_words("abcdef"), "abcdef");
-
-        let r = dc_encode_header_words(
-            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
-        );
-        assert!(r.starts_with("=?utf-8"));
-
-        assert_eq!(
-            dc_decode_header_words(&r),
-            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
-        );
-
-        assert_eq!(
-                dc_decode_header_words("=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?="),
-                std::string::String::from_utf8(b"attachment;\r\n filename=\"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\";\r\n size=39".to_vec()).unwrap(),
+        unsafe {
+            let mut buf1: *mut libc::c_char = dc_decode_header_words(
+                b"=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?=\x00" as *const u8 as *const libc::c_char,
             );
+            assert_eq!(
+                strcmp(
+                    buf1,
+                    b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\x00" as *const u8 as *const libc::c_char
+                ),
+                0
+            );
+            free(buf1 as *mut libc::c_void);
+
+            buf1 =
+                dc_decode_header_words(b"just ascii test\x00" as *const u8 as *const libc::c_char);
+            assert_eq!(CStr::from_ptr(buf1).to_str().unwrap(), "just ascii test");
+            free(buf1 as *mut libc::c_void);
+
+            assert_eq!(dc_encode_header_words("abcdef"), "abcdef");
+
+            let r = dc_encode_header_words(
+                std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec())
+                    .unwrap(),
+            );
+            assert!(r.starts_with("=?utf-8"));
+
+            buf1 = r.strdup();
+            let buf2: *mut libc::c_char = dc_decode_header_words(buf1);
+            assert_eq!(
+                strcmp(
+                    buf2,
+                    b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\x00" as *const u8 as *const libc::c_char
+                ),
+                0
+            );
+            free(buf2 as *mut libc::c_void);
+
+            buf1 = dc_decode_header_words(
+                b"=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?=\x00" as *const u8 as *const libc::c_char
+            );
+            assert_eq!(
+                strcmp(
+                    buf1,
+                    b"attachment;\r\n filename=\"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\";\r\n size=39\x00" as *const u8 as *const libc::c_char,
+
+                ),
+                0
+            );
+        }
     }
 
     #[test]
@@ -224,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! {
@@ -239,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(&encoded);
-
-            assert_eq!(input, decoded);
-        }
     }
 }

src/dc_tools.rs

@@ -1,16 +1,15 @@
 //! Some tools and enhancements to the used libraries, there should be
 //! no references to Context and other "larger" entities here.
 
-use core::cmp::max;
 use std::borrow::Cow;
-use std::ffi::{CStr, CString};
+use std::ffi::{CStr, CString, OsString};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::SystemTime;
 use std::{fmt, fs, ptr};
 
 use chrono::{Local, TimeZone};
-use libc::{memcpy, strlen};
+use libc::{memcpy, strcpy, strlen, uintptr_t};
 use mmime::clist::*;
 use mmime::mailimf::types::*;
 use rand::{thread_rng, Rng};
@@ -150,6 +149,66 @@ pub(crate) fn dc_truncate(buf: &str, approx_chars: usize, do_unwrap: bool) -> Co
     }
 }
 
+#[allow(non_snake_case)]
+pub(crate) unsafe fn dc_truncate_n_unwrap_str(
+    buf: *mut libc::c_char,
+    approx_characters: libc::c_int,
+    do_unwrap: libc::c_int,
+) {
+    /* Function unwraps the given string and removes unnecessary whitespace.
+    Function stops processing after approx_characters are processed.
+    (as we're using UTF-8, for simplicity, we cut the string only at whitespaces). */
+    /* a single line is truncated `...` instead of `[...]` (the former is typically also used by the UI to fit strings in a rectangle) */
+    let ellipse_utf8: *const libc::c_char = if 0 != do_unwrap {
+        b" ...\x00" as *const u8 as *const libc::c_char
+    } else {
+        b" [...]\x00" as *const u8 as *const libc::c_char
+    };
+    let mut lastIsCharacter: libc::c_int = 0;
+    /* force unsigned - otherwise the `> ' '` comparison will fail */
+    let mut p1: *mut libc::c_uchar = buf as *mut libc::c_uchar;
+    while 0 != *p1 {
+        if *p1 as libc::c_int > ' ' as i32 {
+            lastIsCharacter = 1
+        } else if 0 != lastIsCharacter {
+            let used_bytes = (p1 as uintptr_t).wrapping_sub(buf as uintptr_t) as libc::size_t;
+            if dc_utf8_strnlen(buf, used_bytes) >= approx_characters as usize {
+                let buf_bytes = strlen(buf);
+                if buf_bytes.wrapping_sub(used_bytes) >= strlen(ellipse_utf8) {
+                    strcpy(p1 as *mut libc::c_char, ellipse_utf8);
+                }
+                break;
+            } else {
+                lastIsCharacter = 0;
+                if 0 != do_unwrap {
+                    *p1 = ' ' as i32 as libc::c_uchar
+                }
+            }
+        } else if 0 != do_unwrap {
+            *p1 = '\r' as i32 as libc::c_uchar
+        }
+        p1 = p1.offset(1isize)
+    }
+    if 0 != do_unwrap {
+        dc_remove_cr_chars(buf);
+    };
+}
+
+unsafe fn dc_utf8_strnlen(s: *const libc::c_char, n: libc::size_t) -> libc::size_t {
+    if s.is_null() {
+        return 0;
+    }
+
+    let mut j: libc::size_t = 0;
+    for i in 0..n {
+        if *s.add(i) as libc::c_int & 0xc0 != 0x80 {
+            j = j.wrapping_add(1)
+        }
+    }
+
+    j
+}
+
 pub(crate) unsafe fn dc_str_from_clist(
     list: *const clist,
     delimiter: *const libc::c_char,
@@ -218,26 +277,26 @@ pub(crate) fn dc_str_to_color(s: impl AsRef<str>) -> u32 {
 
 /* date/time tools */
 /* the result is UTC or DC_INVALID_TIMESTAMP */
-pub(crate) fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> i64 {
-    assert!(!date_time.is_null());
-    let dt = unsafe { *date_time };
-
-    let sec = dt.dt_sec;
-    let min = dt.dt_min;
-    let hour = dt.dt_hour;
-    let day = dt.dt_day;
-    let month = dt.dt_month;
-    let year = dt.dt_year;
+pub(crate) unsafe fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> i64 {
+    let sec = (*date_time).dt_sec;
+    let min = (*date_time).dt_min;
+    let hour = (*date_time).dt_hour;
+    let day = (*date_time).dt_day;
+    let month = (*date_time).dt_month;
+    let year = (*date_time).dt_year;
 
     let ts = chrono::NaiveDateTime::new(
         chrono::NaiveDate::from_ymd(year, month as u32, day as u32),
         chrono::NaiveTime::from_hms(hour as u32, min as u32, sec as u32),
     );
 
-    let (zone_hour, zone_min) = if dt.dt_zone >= 0 {
-        (dt.dt_zone / 100, dt.dt_zone % 100)
+    let (zone_hour, zone_min) = if (*date_time).dt_zone >= 0 {
+        ((*date_time).dt_zone / 100, (*date_time).dt_zone % 100)
     } else {
-        (-(-dt.dt_zone / 100), -(-dt.dt_zone % 100))
+        (
+            -(-(*date_time).dt_zone / 100),
+            -(-(*date_time).dt_zone % 100),
+        )
     };
 
     ts.timestamp() - (zone_hour * 3600 + zone_min * 60) as i64
@@ -416,41 +475,12 @@ pub(crate) fn dc_ensure_no_slash_safe(path: &str) -> &str {
     path
 }
 
-// Function returns a sanitized basename that does not contain
-// win/linux path separators and also not any non-ascii chars
-fn get_safe_basename(filename: &str) -> String {
-    // return the (potentially mangled) basename of the input filename
-    // this might be a path that comes in from another operating system
-    let mut index: usize = 0;
-
-    if let Some(unix_index) = filename.rfind("/") {
-        index = unix_index + 1;
-    }
-    if let Some(win_index) = filename.rfind("\\") {
-        index = max(index, win_index + 1);
-    }
-    if index >= filename.len() {
-        "nobasename".to_string()
-    } else {
-        // we don't allow any non-ascii to be super-safe
-        filename[index..].replace(|c: char| !c.is_ascii() || c == ':', "-")
-    }
-}
-
-pub fn dc_derive_safe_stem_ext(filename: &str) -> (String, String) {
-    let basename = get_safe_basename(&filename);
-    let (mut stem, mut ext) = if let Some(index) = basename.rfind(".") {
-        (
-            basename[0..index].to_string(),
-            basename[index..].to_string(),
-        )
-    } else {
-        (basename, "".to_string())
-    };
-    // limit length of stem and ext
-    stem.truncate(32);
-    ext.truncate(32);
-    (stem, ext)
+/// Function modifies the given buffer and replaces all characters not valid in filenames by a "-".
+fn validate_filename(filename: &str) -> String {
+    filename
+        .replace('/', "-")
+        .replace('\\', "-")
+        .replace(':', "-")
 }
 
 // the returned suffix is lower-case
@@ -596,24 +626,49 @@ pub fn dc_read_file<P: AsRef<std::path::Path>>(
     }
 }
 
-pub(crate) fn dc_get_next_backup_path(
+pub(crate) fn dc_get_fine_path_filename(
+    context: &Context,
     folder: impl AsRef<Path>,
-    backup_time: i64,
-) -> Result<PathBuf, Error> {
-    let folder = PathBuf::from(folder.as_ref());
-    let stem = chrono::NaiveDateTime::from_timestamp(backup_time, 0)
-        .format("delta-chat-%Y-%m-%d")
-        .to_string();
+    desired_filename_suffix: impl AsRef<str>,
+) -> PathBuf {
+    let now = time();
 
-    // 64 backup files per day should be enough for everyone
-    for i in 0..64 {
-        let mut path = folder.clone();
-        path.push(format!("{}-{}.bak", stem, i));
-        if !path.exists() {
-            return Ok(path);
+    let folder = PathBuf::from(folder.as_ref());
+    // XXX sanitize desired_filename eg using
+    // https://github.com/kardeiz/sanitize-filename/blob/master/src/lib.rs
+    let suffix = validate_filename(desired_filename_suffix.as_ref());
+    let file_name = PathBuf::from(suffix);
+    let extension = file_name.extension().map(|c| c.clone());
+
+    for i in 0..100_000 {
+        let ret = if i == 0 {
+            let mut folder = folder.clone();
+            folder.push(&file_name);
+            folder
+        } else {
+            let idx = if i < 100 { i } else { now + i };
+            let file_name = if let Some(stem) = file_name.file_stem() {
+                let mut stem = stem.to_os_string();
+                stem.push(format!("-{}", idx));
+                stem
+            } else {
+                OsString::from(idx.to_string())
+            };
+            let mut folder = folder.clone();
+            folder.push(file_name);
+            if let Some(ext) = extension {
+                folder.set_extension(&ext);
+            }
+            folder
+        };
+
+        if !dc_file_exist(context, &ret) {
+            // fine filename found
+            return ret;
         }
     }
-    bail!("could not create backup file, disk full?");
+
+    panic!("Something is really wrong, you need to clean up your disk");
 }
 
 pub(crate) fn dc_is_blobdir_path(context: &Context, path: impl AsRef<str>) -> bool {
@@ -641,10 +696,13 @@ pub(crate) fn dc_make_rel_and_copy(context: &Context, path: &mut String) -> bool
         dc_make_rel_path(context, path);
         return true;
     }
-    if let Ok(blobdir_path) = context.copy_to_blobdir(&path) {
-        *path = blobdir_path;
+    let blobdir_path = dc_get_fine_path_filename(context, "$BLOBDIR", &path);
+    if dc_copy_file(context, &path, &blobdir_path) {
+        *path = blobdir_path.to_string_lossy().to_string();
+        dc_make_rel_path(context, path);
         return true;
     }
+
     false
 }
 
@@ -1439,19 +1497,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_file_get_safe_basename() {
-        assert_eq!(get_safe_basename("12312/hello"), "hello");
-        assert_eq!(get_safe_basename("12312\\hello"), "hello");
-        assert_eq!(get_safe_basename("//12312\\hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12\\hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12/\\\\hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12//hello"), "hello");
-        assert_eq!(get_safe_basename("//123:12//"), "nobasename");
-        assert_eq!(get_safe_basename("//123:12/"), "nobasename");
-        assert!(get_safe_basename("123\x012.hello").ends_with(".hello"));
-    }
-
     #[test]
     fn test_file_handling() {
         let t = dummy_context();
@@ -1486,7 +1531,6 @@ mod tests {
         assert!(dc_file_exist(context, &abs_path));
 
         assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
-
         assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada",), 7);
 
         let buf = dc_read_file(context, "$BLOBDIR/dada").unwrap();
@@ -1499,12 +1543,14 @@ mod tests {
         assert!(dc_create_folder(context, "$BLOBDIR/foobar-folder"));
         assert!(dc_file_exist(context, "$BLOBDIR/foobar-folder",));
         assert!(!dc_delete_file(context, "$BLOBDIR/foobar-folder"));
+        let fn0 = dc_get_fine_path_filename(context, "$BLOBDIR", "foobar.dadada");
+        assert_eq!(fn0, PathBuf::from("$BLOBDIR/foobar.dadada"));
 
-        let fn0 = "$BLOBDIR/data.data";
         assert!(dc_write_file(context, &fn0, b"content"));
+        let fn1 = dc_get_fine_path_filename(context, "$BLOBDIR", "foobar.dadada");
+        assert_eq!(fn1, PathBuf::from("$BLOBDIR/foobar-1.dadada"));
 
         assert!(dc_delete_file(context, &fn0));
-        assert!(!dc_file_exist(context, &fn0));
     }
 
     #[test]

src/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);
@@ -965,39 +965,41 @@ fn send_mdn(context: &Context, msg_id: u32) {
 
 #[allow(non_snake_case)]
 fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) -> libc::c_int {
+    let mut success: libc::c_int = 0i32;
     let mut param = Params::new();
+    let path_filename = dc_get_fine_path_filename(context, "$BLOBDIR", &mimefactory.rfc724_mid);
     let bytes = unsafe {
         std::slice::from_raw_parts(
             (*mimefactory.out).str_0 as *const u8,
             (*mimefactory.out).len,
         )
     };
-    let bpath = match context.new_blob_file(&mimefactory.rfc724_mid, bytes) {
-        Ok(path) => path,
-        Err(err) => {
-            error!(
-                context,
-                "Could not write {} smtp-message, error {}", mimefactory.rfc724_mid, err
-            );
-            return 0;
-        }
-    };
-    info!(context, "add_smtp_job file written: {:?}", bpath);
-    let recipients = mimefactory.recipients_addr.join("\x1e");
-    param.set(Param::File, &bpath);
-    param.set(Param::Recipients, &recipients);
-    job_add(
-        context,
-        action,
-        (if mimefactory.loaded == Loaded::Message {
-            mimefactory.msg.id
-        } else {
-            0
-        }) as libc::c_int,
-        param,
-        0,
-    );
-    1
+    if !dc_write_file(context, &path_filename, bytes) {
+        error!(
+            context,
+            "Could not write message <{}> to \"{}\".",
+            mimefactory.rfc724_mid,
+            path_filename.display(),
+        );
+    } else {
+        info!(context, "add_smtp_job file written: {:?}", path_filename);
+        let recipients = mimefactory.recipients_addr.join("\x1e");
+        param.set(Param::File, path_filename.to_string_lossy());
+        param.set(Param::Recipients, &recipients);
+        job_add(
+            context,
+            action,
+            (if mimefactory.loaded == Loaded::Message {
+                mimefactory.msg.id
+            } else {
+                0
+            }) as libc::c_int,
+            param,
+            0,
+        );
+        success = 1;
+    }
+    success
 }
 
 pub fn job_add(

src/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/message.rs

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

src/mimefactory.rs

@@ -16,7 +16,7 @@ use crate::chat::{self, Chat};
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::{get_version_str, Context};
-use crate::dc_mimeparser::SystemMessage;
+use crate::dc_mimeparser::{mailmime_find_mailimf_fields, SystemMessage};
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
 use crate::e2ee::*;
@@ -645,7 +645,7 @@ impl<'a> MimeFactory<'a> {
         );
 
         /*just a pointer into mailmime structure, must not be freed*/
-        let imffields_unprotected = wrapmime::mailmime_find_mailimf_fields(message);
+        let imffields_unprotected = mailmime_find_mailimf_fields(message);
         ensure!(
             !imffields_unprotected.is_null(),
             "could not find mime fields"

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/top_evil_rs.py

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

src/wrapmime.rs

@@ -1,20 +1,14 @@
-use std::collections::HashSet;
 use std::ffi::CString;
-use std::ptr;
 
-use crate::contact::addr_normalize;
 use crate::dc_tools::*;
 use crate::error::Error;
 use mmime::clist::*;
-// use mmime::display::*;
 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::*;
 use mmime::mailmime::*;
-use mmime::mmapstring::*;
 use mmime::other::*;
 
 #[macro_export]
@@ -31,398 +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 parse_mailmime(input: &Vec<u8>) -> Result<*Mailmime> {
-    let mut parsed_mime = ptr::null_mut();
-    let mut index = 0;
-    let res = unsafe { mailmime_parse(
-        decrypt_info.plain.as_ptr() as *const _,
-        decrypt_info.plain.len(),
-        &mut index,
-        &mut parsed_mime,
-    ) };
-    if res == MAIL_NO_ERROR && parsed_mime != ptr::null_mut() {
-        // mailmime_substitute detaches mime from its position in the mime tree 
-        // and puts decrypted_mime in its position. Afterwars mime is dangling. 
-        Ok(parsed_mime)
-    } else {
-        Err("could not parse mime structure");
-    }
-}
-
-pub fn get_field_from(imffields: *mut mailimf_fields) -> Result<String, Error> {
-    let field = mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
-    if !field.is_null() && unsafe { !(*field).fld_data.fld_from.is_null() } {
-        let mb_list = unsafe { (*(*field).fld_data.fld_from).frm_mb_list };
-        if let Some(addr) = mailimf_find_first_addr(mb_list) {
-            return Ok(addr);
-        }
-    }
-    bail!("not From field found");
-}
-
-pub fn get_field_date(imffields: *mut mailimf_fields) -> Result<i64, Error> {
-    let field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
-    let mut message_time = 0;
-
-    if !field.is_null() && unsafe { !(*field).fld_data.fld_orig_date.is_null() } {
-        let orig_date = unsafe { (*field).fld_data.fld_orig_date };
-
-        if !orig_date.is_null() {
-            let dt = unsafe { (*orig_date).dt_date_time };
-            message_time = dc_timestamp_from_date(dt);
-            if message_time != 0 && message_time > time() {
-                message_time = time()
-            }
-        }
-    }
-
-    Ok(message_time)
-}
-
-fn mailimf_get_recipients_add_addr(recipients: &mut HashSet<String>, mb: *mut mailimf_mailbox) {
-    if !mb.is_null() {
-        let addr_norm = addr_normalize(as_str(unsafe { (*mb).mb_addr_spec }));
-        recipients.insert(addr_norm.into());
-    }
-}
-
-/*the result is a pointer to mime, must not be freed*/
-pub fn mailimf_find_field(
-    header: *mut mailimf_fields,
-    wanted_fld_type: libc::c_int,
-) -> *mut mailimf_field {
-    if header.is_null() {
-        return ptr::null_mut();
-    }
-
-    let header = unsafe { (*header) };
-    if header.fld_list.is_null() {
-        return ptr::null_mut();
-    }
-
-    for cur in unsafe { &(*header.fld_list) } {
-        let field = cur as *mut mailimf_field;
-        if !field.is_null() {
-            if unsafe { (*field).fld_type } == wanted_fld_type {
-                return field;
-            }
-        }
-    }
-
-    ptr::null_mut()
-}
-
-/*the result is a pointer to mime, must not be freed*/
-pub unsafe fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
-    if mime.is_null() {
-        return ptr::null_mut();
-    }
-
-    match (*mime).mm_type as _ {
-        MAILMIME_MULTIPLE => {
-            for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
-                let header = mailmime_find_mailimf_fields(cur_data as *mut _);
-                if !header.is_null() {
-                    return header;
-                }
-            }
-        }
-        MAILMIME_MESSAGE => return (*mime).mm_data.mm_message.mm_fields,
-        _ => {}
-    }
-
-    ptr::null_mut()
-}
-
-pub unsafe fn mailimf_find_optional_field(
-    header: *mut mailimf_fields,
-    wanted_fld_name: *const libc::c_char,
-) -> *mut mailimf_optional_field {
-    if header.is_null() || (*header).fld_list.is_null() {
-        return ptr::null_mut();
-    }
-    for cur_data in (*(*header).fld_list).into_iter() {
-        let field: *mut mailimf_field = cur_data as *mut _;
-
-        if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let optional_field: *mut mailimf_optional_field = (*field).fld_data.fld_optional_field;
-            if !optional_field.is_null()
-                && !(*optional_field).fld_name.is_null()
-                && !(*optional_field).fld_value.is_null()
-                && strcasecmp((*optional_field).fld_name, wanted_fld_name) == 0i32
-            {
-                return optional_field;
-            }
-        }
-    }
-
-    ptr::null_mut()
-}
-
-pub fn iter_optional_field_values(
-    header: *const mailimf_fields,
-    wanted_fld_name: *const libc::c_char,
-) -> Result<Vec<String>, Error> {
-    ensure!(
-        !header.is_null() && unsafe { !(*header).fld_list.is_null() },
-        "iter_optional_fields: invalid input"
-    );
-    let mut result = Vec::default();
-    for cur_data in unsafe { (*(*header).fld_list).into_iter() } {
-        let field: *mut mailimf_field = cur_data as *mut _;
-
-        unsafe {
-            if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-                let optional_field: *mut mailimf_optional_field =
-                    (*field).fld_data.fld_optional_field;
-                if !optional_field.is_null()
-                    && !(*optional_field).fld_name.is_null()
-                    && !(*optional_field).fld_value.is_null()
-                    && strcasecmp((*optional_field).fld_name, wanted_fld_name) == 0i32
-                {
-                    result.push(to_string((*optional_field).fld_value));
-                }
-            }
-        }
-    }
-    Ok(result)
-}
-
-pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String> {
-    /* returned addresses are normalized. */
-    let mut recipients: HashSet<String> = Default::default();
-
-    for cur in unsafe { (*(*imffields).fld_list).into_iter() } {
-        let fld = cur as *mut mailimf_field;
-
-        let fld_to: *mut mailimf_to;
-        let fld_cc: *mut mailimf_cc;
-
-        let mut addr_list: *mut mailimf_address_list = ptr::null_mut();
-        if fld.is_null() {
-            continue;
-        }
-
-        let fld = unsafe { *fld };
-
-        // TODO match on enums /rtn
-        match fld.fld_type {
-            13 => {
-                fld_to = unsafe { fld.fld_data.fld_to };
-                if !fld_to.is_null() {
-                    addr_list = unsafe { (*fld_to).to_addr_list };
-                }
-            }
-            14 => {
-                fld_cc = unsafe { fld.fld_data.fld_cc };
-                if !fld_cc.is_null() {
-                    addr_list = unsafe { (*fld_cc).cc_addr_list };
-                }
-            }
-            _ => {}
-        }
-
-        if !addr_list.is_null() {
-            for cur2 in unsafe { &(*(*addr_list).ad_list) } {
-                let adr = cur2 as *mut mailimf_address;
-
-                if adr.is_null() {
-                    continue;
-                }
-                let adr = unsafe { *adr };
-
-                if adr.ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
-                    mailimf_get_recipients_add_addr(&mut recipients, unsafe {
-                        adr.ad_data.ad_mailbox
-                    });
-                } else if adr.ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
-                    let group = unsafe { adr.ad_data.ad_group };
-                    if !group.is_null() && unsafe { !(*group).grp_mb_list.is_null() } {
-                        for cur3 in unsafe { &(*(*(*group).grp_mb_list).mb_list) } {
-                            mailimf_get_recipients_add_addr(
-                                &mut recipients,
-                                cur3 as *mut mailimf_mailbox,
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    recipients
-}
-
-pub fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, Error> {
-    ensure!(!mime.is_null(), "invalid inputs");
-
-    let mime_transfer_encoding =
-        get_mime_transfer_encoding(mime).unwrap_or(MAILMIME_MECHANISM_BINARY as i32);
-
-    let mime_data = unsafe { (*mime).mm_data.mm_single };
-
-    decode_dt_data(mime_data, mime_transfer_encoding)
-}
-
-pub fn get_mime_transfer_encoding(mime: *mut Mailmime) -> Option<libc::c_int> {
-    unsafe {
-        let mm_mime_fields = (*mime).mm_mime_fields;
-        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<Vec<u8>, Error> {
-    // Decode data according to mime_transfer_encoding
-    // returns Ok with a (decoded_data,decoded_data_bytes) pointer
-    // where the caller must make sure to free it.
-    // It may return Ok(ptr::null_mut(), 0)
-    if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int
-        || mime_transfer_encoding == MAILMIME_MECHANISM_8BIT as libc::c_int
-        || mime_transfer_encoding == MAILMIME_MECHANISM_BINARY as libc::c_int
-    {
-        let decoded_data = unsafe { (*mime_data).dt_data.dt_text.dt_data };
-        let decoded_data_bytes = unsafe { (*mime_data).dt_data.dt_text.dt_length };
-
-        if decoded_data.is_null() || decoded_data_bytes <= 0 {
-            bail!("No data to decode found");
-        } else {
-            let result = unsafe {
-                std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes)
-            };
-            return Ok(result.to_vec());
-        }
-    }
-    // unsafe { display_mime_data(mime_data) };
-
-    let mut current_index = 0;
-    let mut transfer_decoding_buffer = ptr::null_mut();
-    let mut decoded_data_bytes = 0;
-
-    let r = unsafe {
-        mailmime_part_parse(
-            (*mime_data).dt_data.dt_text.dt_data,
-            (*mime_data).dt_data.dt_text.dt_length,
-            &mut current_index,
-            mime_transfer_encoding,
-            &mut transfer_decoding_buffer,
-            &mut decoded_data_bytes,
-        )
-    };
-
-    if r == MAILIMF_NO_ERROR as libc::c_int
-        && !transfer_decoding_buffer.is_null()
-        && decoded_data_bytes > 0
-    {
-        let result = unsafe {
-            std::slice::from_raw_parts(transfer_decoding_buffer as *const u8, decoded_data_bytes)
-        }
-        .to_vec();
-        // we return a fresh vec and transfer_decoding_buffer is not used or passed anywhere
-        // so it's safe to free it right away, as mailman_part_parse has
-        // allocated it fresh.
-        unsafe { mmap_string_unref(transfer_decoding_buffer) };
-
-        return Ok(result);
-    }
-
-    Err(format_err!("Failed to to decode"))
-}
-
-pub fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> Option<String> {
-    if mb_list.is_null() {
-        return None;
-    }
-
-    for cur in unsafe { (*(*mb_list).mb_list).into_iter() } {
-        let mb = cur as *mut mailimf_mailbox;
-        if !mb.is_null() && !unsafe { (*mb).mb_addr_spec.is_null() } {
-            let addr = unsafe { as_str((*mb).mb_addr_spec) };
-            return Some(addr_normalize(addr).to_string());
-        }
-    }
-
-    None
-}
-
-/**************************************
-* 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-----