fix failing array asserts #355

Implement procedural macro to derive {To,From}Sql traits

Cargo.lock

@@ -467,10 +467,12 @@ dependencies = [
  "cc 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)",
  "charset 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "chrono 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "deltachat_derive 0.1.0",
  "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "imap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lettre 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -500,6 +502,14 @@ dependencies = [
  "thread-local-object 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "deltachat_derive"
+version = "0.1.0"
+dependencies = [
+ "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.14.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "deltachat_ffi"
 version = "1.0.0-alpha.3"
@@ -927,6 +937,14 @@ dependencies = [
  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "itoa"
 version = "0.4.4"
@@ -2762,6 +2780,7 @@ dependencies = [
 "checksum imap-proto 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c4e77b1d61faf028893531b071cc5584cdd02b6186cebe7f7168ffd8d591339a"
 "checksum indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7e81a7c05f79578dbc15793d8b619db9ba32b4577003ef3af1a91c416798c58d"
 "checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
+"checksum itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5b8467d9c1cebe26feb08c640139247fac215782d35371ade9a2136ed6085358"
 "checksum itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f"
 "checksum keccak 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
 "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"

Cargo.toml

@@ -10,6 +10,7 @@ cc = "1.0.35"
 pkg-config = "0.3"
 
 [dependencies]
+deltachat_derive = { path = "./deltachat_derive" }
 libc = "0.2.51"
 pgp = { version = "0.2", default-features = false }
 hex = "0.3.2"
@@ -44,6 +45,7 @@ strum_macros = "0.15.0"
 thread-local-object = "0.1.0"
 backtrace = "0.3.33"
 byteorder = "1.3.1"
+itertools = "0.8.0"
 
 [dev-dependencies]
 tempfile = "3.0"
@@ -52,7 +54,8 @@ pretty_env_logger = "0.3.0"
 
 [workspace]
 members = [
-  "deltachat-ffi"
+  "deltachat-ffi",
+  "deltachat_derive",
 ]
 
 [[example]]

README.md

@@ -89,6 +89,14 @@ $ cargo test --all
 $ cargo build -p deltachat_ffi --release
 ```
 
+### Expensive tests
+
+Some tests are expensive and marked with `#[ignore]`, to run these
+use the `--ignored` argument to the test binary (not to cargo itself):
+```sh
+$ cargo test -- --ignored
+```
+
 ## Features
 
 - `vendored`: When using Openssl for TLS, this bundles a vendored version.

ci_scripts/ci_run.sh

@@ -16,7 +16,7 @@ export BRANCH=${CIRCLE_BRANCH:-test7}
 #fi
 
 # run everything else inside docker (TESTS, DOCS, WHEELS) 
-docker run -e BRANCH -e TESTS -e DOCS \
+docker run -e DCC_PY_LIVECONFIG -e BRANCH -e TESTS -e DOCS \
            --rm -it -v $(pwd):/mnt -w /mnt \
            deltachat/coredeps ci_scripts/run_all.sh
 

ci_scripts/ci_upload.sh

@@ -15,6 +15,7 @@ export BRANCH=${CIRCLE_BRANCH:?specify branch for uploading purposes}
 
 
 # python docs to py.delta.chat
+ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null delta@py.delta.chat mkdir -p build/${BRANCH}
 rsync -avz \
   -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
   "$PYDOCDIR/html/" \
@@ -37,11 +38,13 @@ pip install devpi-client
 devpi use https://m.devpi.net
 devpi login dc --password $DEVPI_LOGIN
 
-devpi use dc/$BRANCH || {
-    devpi index -c $BRANCH 
-    devpi use dc/$BRANCH
+N_BRANCH=${BRANCH//[\/]}
+
+devpi use dc/$N_BRANCH || {
+    devpi index -c $N_BRANCH 
+    devpi use dc/$N_BRANCH
 }
-devpi index $BRANCH bases=/root/pypi
+devpi index $N_BRANCH bases=/root/pypi
 devpi upload deltachat*.whl
 
 popd

ci_scripts/docker-coredeps/deps/build_rust.sh

@@ -3,9 +3,9 @@
 set -e -x 
 
 # Install Rust 
-curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2019-04-19 -y
+curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2019-07-10 -y
 export PATH=/root/.cargo/bin:$PATH
 rustc --version
 
 # remove some 300-400 MB that we don't need for automated builds
-rm -rf /root/.rustup/toolchains/nightly-2019-04-19-x86_64-unknown-linux-gnu/share/
+rm -rf /root/.rustup/toolchains/nightly-2019-07-10-x86_64-unknown-linux-gnu/share/

ci_scripts/run_all.sh

@@ -37,6 +37,10 @@ if [ -n "$TESTS" ]; then
     export PYTHONDONTWRITEBYTECODE=1
 
     # run tox
+    # XXX we don't run liveconfig tests because they hang sometimes
+    # see https://github.com/deltachat/deltachat-core-rust/issues/331
+    unset DCC_PY_LIVECONFIG
+
     tox --workdir "$TOXWORKDIR" -e lint,py27,py35,py36,py37,auditwheels
     popd
 fi

deltachat_derive/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "deltachat_derive"
+version = "0.1.0"
+authors = ["Dmitry Bogatov <KAction@debian.org>"]
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "0.14.4"
+quote = "0.6.3"

deltachat_derive/src/lib.rs

@@ -0,0 +1,45 @@
+#![recursion_limit = "128"]
+extern crate proc_macro;
+
+use crate::proc_macro::TokenStream;
+use quote::quote;
+use syn;
+
+// For now, assume (not check) that these macroses are applied to enum without
+// data.  If this assumption is violated, compiler error will point to
+// generated code, which is not very user-friendly.
+
+#[proc_macro_derive(ToSql)]
+pub fn to_sql_derive(input: TokenStream) -> TokenStream {
+    let ast: syn::DeriveInput = syn::parse(input).unwrap();
+    let name = &ast.ident;
+
+    let gen = quote! {
+        impl rusqlite::types::ToSql for #name {
+            fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
+                let num = *self as i64;
+                let value = rusqlite::types::Value::Integer(num);
+                let output = rusqlite::types::ToSqlOutput::Owned(value);
+
+                std::result::Result::Ok(output)
+            }
+        }
+    };
+    gen.into()
+}
+
+#[proc_macro_derive(FromSql)]
+pub fn from_sql_derive(input: TokenStream) -> TokenStream {
+    let ast: syn::DeriveInput = syn::parse(input).unwrap();
+    let name = &ast.ident;
+
+    let gen = quote! {
+        impl rusqlite::types::FromSql for #name {
+            fn column_result(col: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
+                let inner = rusqlite::types::FromSql::column_result(col)?;
+                num_traits::FromPrimitive::from_i64(inner).ok_or(rusqlite::types::FromSqlError::InvalidType)
+            }
+        }
+    };
+    gen.into()
+}

examples/repl/cmdline.rs

@@ -4,11 +4,11 @@ use std::str::FromStr;
 use deltachat::chatlist::*;
 use deltachat::config;
 use deltachat::constants::*;
+use deltachat::contact::*;
 use deltachat::context::*;
 use deltachat::dc_array::*;
 use deltachat::dc_chat::*;
 use deltachat::dc_configure::*;
-use deltachat::dc_contact::*;
 use deltachat::dc_imex::*;
 use deltachat::dc_job::*;
 use deltachat::dc_location::*;
@@ -125,7 +125,7 @@ unsafe fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int
         return 0;
     }
 
-    let mut current_block: u64;
+    let ok_to_continue;
     let mut success: libc::c_int = 0;
     let real_spec: *mut libc::c_char;
     let mut suffix: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -138,77 +138,71 @@ unsafe fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int
             .sql
             .set_config(context, "import_spec", Some(as_str(real_spec)))
             .unwrap();
-        current_block = 7149356873433890176;
+        ok_to_continue = true;
     } else {
         let rs = context.sql.get_config(context, "import_spec");
         if rs.is_none() {
             error!(context, 0, "Import: No file or folder given.");
-            current_block = 8522321847195001863;
+            ok_to_continue = false;
         } else {
-            current_block = 7149356873433890176;
+            ok_to_continue = true;
         }
         real_spec = rs.unwrap_or_default().strdup();
     }
-    match current_block {
-        8522321847195001863 => {}
-        _ => {
-            suffix = dc_get_filesuffix_lc(real_spec);
-            if !suffix.is_null()
-                && strcmp(suffix, b"eml\x00" as *const u8 as *const libc::c_char) == 0
-            {
-                if 0 != dc_poke_eml_file(context, real_spec) {
-                    read_cnt += 1
-                }
-                current_block = 1622411330066726685;
+    if ok_to_continue {
+        let ok_to_continue2;
+        suffix = dc_get_filesuffix_lc(real_spec);
+        if !suffix.is_null() && strcmp(suffix, b"eml\x00" as *const u8 as *const libc::c_char) == 0
+        {
+            if 0 != dc_poke_eml_file(context, real_spec) {
+                read_cnt += 1
+            }
+            ok_to_continue2 = true;
+        } else {
+            /* import a directory */
+            let dir_name = std::path::Path::new(as_str(real_spec));
+            let dir = std::fs::read_dir(dir_name);
+            if dir.is_err() {
+                error!(
+                    context,
+                    0,
+                    "Import: Cannot open directory \"{}\".",
+                    as_str(real_spec),
+                );
+                ok_to_continue2 = false;
             } else {
-                /* import a directory */
-                let dir_name = std::path::Path::new(as_str(real_spec));
-                let dir = std::fs::read_dir(dir_name);
-                if dir.is_err() {
-                    error!(
-                        context,
-                        0,
-                        "Import: Cannot open directory \"{}\".",
-                        as_str(real_spec),
-                    );
-                    current_block = 8522321847195001863;
-                } else {
-                    let dir = dir.unwrap();
-                    for entry in dir {
-                        if entry.is_err() {
-                            break;
-                        }
-                        let entry = entry.unwrap();
-                        let name_f = entry.file_name();
-                        let name = name_f.to_string_lossy();
-                        if name.ends_with(".eml") {
-                            let path_plus_name = format!("{}/{}", as_str(real_spec), name);
-                            info!(context, 0, "Import: {}", path_plus_name);
-                            let path_plus_name_c = CString::yolo(path_plus_name);
-                            if 0 != dc_poke_eml_file(context, path_plus_name_c.as_ptr()) {
-                                read_cnt += 1
-                            }
+                let dir = dir.unwrap();
+                for entry in dir {
+                    if entry.is_err() {
+                        break;
+                    }
+                    let entry = entry.unwrap();
+                    let name_f = entry.file_name();
+                    let name = name_f.to_string_lossy();
+                    if name.ends_with(".eml") {
+                        let path_plus_name = format!("{}/{}", as_str(real_spec), name);
+                        info!(context, 0, "Import: {}", path_plus_name);
+                        let path_plus_name_c = CString::yolo(path_plus_name);
+                        if 0 != dc_poke_eml_file(context, path_plus_name_c.as_ptr()) {
+                            read_cnt += 1
                         }
                     }
-                    current_block = 1622411330066726685;
                 }
+                ok_to_continue2 = true;
             }
-            match current_block {
-                8522321847195001863 => {}
-                _ => {
-                    info!(
-                        context,
-                        0,
-                        "Import: {} items read from \"{}\".",
-                        read_cnt,
-                        as_str(real_spec)
-                    );
-                    if read_cnt > 0 {
-                        context.call_cb(Event::MSGS_CHANGED, 0 as uintptr_t, 0 as uintptr_t);
-                    }
-                    success = 1
-                }
+        }
+        if ok_to_continue2 {
+            info!(
+                context,
+                0,
+                "Import: {} items read from \"{}\".",
+                read_cnt,
+                as_str(real_spec)
+            );
+            if read_cnt > 0 {
+                context.call_cb(Event::MSGS_CHANGED, 0 as uintptr_t, 0 as uintptr_t);
             }
+            success = 1
         }
     }
 
@@ -218,9 +212,10 @@ unsafe fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int
 }
 
 unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: *mut dc_msg_t) {
-    let contact: *mut dc_contact_t = dc_get_contact(context, dc_msg_get_from_id(msg));
-    let contact_name: *mut libc::c_char = dc_contact_get_name(contact);
-    let contact_id: libc::c_int = dc_contact_get_id(contact) as libc::c_int;
+    let contact = Contact::get_by_id(context, dc_msg_get_from_id(msg)).expect("invalid contact");
+    let contact_name = contact.get_name();
+    let contact_id = contact.get_id();
+
     let statestr = match dc_msg_get_state(msg) {
         DC_STATE_OUT_PENDING => " o",
         DC_STATE_OUT_DELIVERED => " √",
@@ -229,7 +224,7 @@ unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: *mut dc_msg_t
         _ => "",
     };
     let temp2 = dc_timestamp_to_str(dc_msg_get_timestamp(msg));
-    let msgtext: *mut libc::c_char = dc_msg_get_text(msg);
+    let msgtext = dc_msg_get_text(msg);
     info!(
         context,
         0,
@@ -242,7 +237,7 @@ unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: *mut dc_msg_t
             ""
         },
         if dc_msg_has_location(msg) { "📍" } else { "" },
-        as_str(contact_name),
+        &contact_name,
         contact_id,
         as_str(msgtext),
         if dc_msg_is_starred(msg) { "★" } else { "" },
@@ -264,8 +259,6 @@ unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: *mut dc_msg_t
         &temp2,
     );
     free(msgtext as *mut libc::c_void);
-    free(contact_name as *mut libc::c_void);
-    dc_contact_unref(contact);
 }
 
 unsafe fn log_msglist(context: &Context, msglist: *mut dc_array_t) {
@@ -302,23 +295,20 @@ unsafe fn log_msglist(context: &Context, msglist: *mut dc_array_t) {
     }
 }
 
-unsafe fn log_contactlist(context: &Context, contacts: *mut dc_array_t) {
-    let mut contact: *mut dc_contact_t;
-    if !dc_array_search_id(contacts, 1 as uint32_t, 0 as *mut size_t) {
-        dc_array_add_id(contacts, 1 as uint32_t);
+unsafe fn log_contactlist(context: &Context, contacts: &Vec<u32>) {
+    let mut contacts = contacts.clone();
+    if !contacts.contains(&1) {
+        contacts.push(1);
     }
-    let cnt = dc_array_get_cnt(contacts);
-    for i in 0..cnt {
-        let contact_id = dc_array_get_id(contacts, i as size_t);
+    for contact_id in contacts {
         let line;
         let mut line2 = "".to_string();
-        contact = dc_get_contact(context, contact_id);
-        if !contact.is_null() {
-            let name: *mut libc::c_char = dc_contact_get_name(contact);
-            let addr: *mut libc::c_char = dc_contact_get_addr(contact);
-            let verified_state: libc::c_int = dc_contact_is_verified(contact);
-            let verified_str = if 0 != verified_state {
-                if verified_state == 2 {
+        if let Ok(contact) = Contact::get_by_id(context, contact_id) {
+            let name = contact.get_name();
+            let addr = contact.get_addr();
+            let verified_state = contact.is_verified();
+            let verified_str = if VerifiedStatus::Unverified != verified_state {
+                if verified_state == VerifiedStatus::BidirectVerified {
                     " √√"
                 } else {
                     " √"
@@ -328,28 +318,26 @@ unsafe fn log_contactlist(context: &Context, contacts: *mut dc_array_t) {
             };
             line = format!(
                 "{}{} <{}>",
-                if !name.is_null() && 0 != *name.offset(0isize) as libc::c_int {
-                    as_str(name)
+                if !name.is_empty() {
+                    &name
                 } else {
                     "<name unset>"
                 },
                 verified_str,
-                if !addr.is_null() && 0 != *addr.offset(0isize) as libc::c_int {
-                    as_str(addr)
+                if !addr.is_empty() {
+                    &addr
                 } else {
                     "addr unset"
                 }
             );
-            let peerstate = Peerstate::from_addr(context, &context.sql, as_str(addr));
+            let peerstate = Peerstate::from_addr(context, &context.sql, &addr);
             if peerstate.is_some() && contact_id != 1 as libc::c_uint {
                 line2 = format!(
                     ", prefer-encrypt={}",
                     peerstate.as_ref().unwrap().prefer_encrypt
                 );
             }
-            dc_contact_unref(contact);
-            free(name as *mut libc::c_void);
-            free(addr as *mut libc::c_void);
+
             info!(context, 0, "Contact#{}: {}{}", contact_id, line, line2);
         }
     }
@@ -476,7 +464,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                  event <event-id to test>\n\
                  fileinfo <file>\n\
                  clear -- clear screen\n\
-                 exit\n\
+                 exit or quit\n\
                  ============================================="
             ),
         },
@@ -609,9 +597,13 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
         }
         "listchats" | "listarchived" | "chats" => {
             let listflags = if arg0 == "listarchived" { 0x01 } else { 0 };
-            let chatlist = Chatlist::try_load(context, listflags, Some(arg1), None)?;
+            let chatlist = Chatlist::try_load(
+                context,
+                listflags,
+                if arg1.is_empty() { None } else { Some(arg1) },
+                None,
+            )?;
 
-            let mut i: usize;
             let cnt = chatlist.len();
             if cnt > 0 {
                 info!(
@@ -619,9 +611,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                     "================================================================================"
                 );
 
-                i = cnt - 1;
-
-                while i > 0 {
+                for i in (0..cnt).rev() {
                     let chat = dc_get_chat(context, chatlist.get_chat_id(i));
                     let temp_subtitle = dc_chat_get_subtitle(chat);
                     let temp_name = dc_chat_get_name(chat);
@@ -675,8 +665,6 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                         context, 0,
                         "================================================================================"
                     );
-
-                    i -= 1
                 }
             }
             if dc_is_sending_locations_to_chat(context, 0 as uint32_t) {
@@ -840,16 +828,14 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             ensure!(!sel_chat.is_null(), "No chat selected.");
 
             let contacts = dc_get_chat_contacts(context, dc_chat_get_id(sel_chat));
-            ensure!(!contacts.is_null(), "Failed to retreive contacts");
             info!(context, 0, "Memberlist:");
 
-            log_contactlist(context, contacts);
+            log_contactlist(context, &contacts);
             println!(
                 "{} contacts\nLocation streaming: {}",
-                dc_array_get_cnt(contacts),
+                contacts.len(),
                 dc_is_sending_locations_to_chat(context, dc_chat_get_id(sel_chat)),
             );
-            dc_array_unref(contacts);
         }
         "getlocations" => {
             let contact_id = arg1.parse().unwrap_or_default();
@@ -914,30 +900,17 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             ensure!(!sel_chat.is_null(), "No chat selected.");
             ensure!(!arg1.is_empty(), "No message text given.");
 
-            let msg = CString::yolo(format!("{} {}", arg1, arg2));
+            let msg = format!("{} {}", arg1, arg2);
 
-            if 0 != dc_send_text_msg(context, dc_chat_get_id(sel_chat), msg.as_ptr()) {
+            if 0 != dc_send_text_msg(context, dc_chat_get_id(sel_chat), msg) {
                 println!("Message sent.");
             } else {
                 bail!("Sending failed.");
             }
         }
-        "send-garbage" => {
-            ensure!(!sel_chat.is_null(), "No chat selected.");
-            let msg = b"\xff\x00"; // NUL-terminated C-string, that is malformed utf-8
-            if 0 != dc_send_text_msg(context, dc_chat_get_id(sel_chat), msg.as_ptr().cast()) {
-                println!("Malformed utf-8 succesfully send. Not nice.");
-            } else {
-                bail!("Garbage sending failed, as expected.");
-            }
-        }
         "sendempty" => {
             ensure!(!sel_chat.is_null(), "No chat selected.");
-            if 0 != dc_send_text_msg(
-                context,
-                dc_chat_get_id(sel_chat),
-                b"\x00" as *const u8 as *const libc::c_char,
-            ) {
+            if 0 != dc_send_text_msg(context, dc_chat_get_id(sel_chat), "".into()) {
                 println!("Message sent.");
             } else {
                 bail!("Sending failed.");
@@ -1073,54 +1046,38 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             dc_delete_msgs(context, ids.as_mut_ptr(), 1);
         }
         "listcontacts" | "contacts" | "listverified" => {
-            let contacts = dc_get_contacts(
+            let contacts = Contact::get_all(
                 context,
                 if arg0 == "listverified" {
                     0x1 | 0x2
                 } else {
                     0x2
                 },
-                arg1_c,
-            );
-            if !contacts.is_null() {
-                log_contactlist(context, contacts);
-                println!("{} contacts.", dc_array_get_cnt(contacts) as libc::c_int,);
-                dc_array_unref(contacts);
-            } else {
-                bail!("");
-            }
+                Some(arg1),
+            )?;
+            log_contactlist(context, &contacts);
+            println!("{} contacts.", contacts.len());
         }
         "addcontact" => {
             ensure!(!arg1.is_empty(), "Arguments [<name>] <addr> expected.");
 
             if !arg2.is_empty() {
-                let book = dc_mprintf(
-                    b"%s\n%s\x00" as *const u8 as *const libc::c_char,
-                    arg1_c,
-                    arg2_c,
-                );
-                dc_add_address_book(context, book);
-                free(book as *mut libc::c_void);
+                let book = format!("{}\n{}", arg1, arg2);
+                Contact::add_address_book(context, book)?;
             } else {
-                if 0 == dc_create_contact(context, 0 as *const libc::c_char, arg1_c) {
-                    bail!("Failed to create contact");
-                }
+                Contact::create(context, "", arg1)?;
             }
         }
         "contactinfo" => {
             ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
 
             let contact_id = arg1.parse()?;
-            let contact = dc_get_contact(context, contact_id);
-            let name_n_addr = dc_contact_get_name_n_addr(contact);
+            let contact = Contact::get_by_id(context, contact_id)?;
+            let name_n_addr = contact.get_name_n_addr();
 
-            let mut res = format!("Contact info for: {}:\n\n", as_str(name_n_addr),);
-            free(name_n_addr as *mut libc::c_void);
-            dc_contact_unref(contact);
+            let mut res = format!("Contact info for: {}:\n\n", name_n_addr);
 
-            let encrinfo = dc_get_contact_encrinfo(context, contact_id);
-            res += as_str(encrinfo);
-            free(encrinfo as *mut libc::c_void);
+            res += &Contact::get_encrinfo(context, contact_id)?;
 
             let chatlist = Chatlist::try_load(context, 0, None, Some(contact_id))?;
             let chatlist_cnt = chatlist.len();
@@ -1143,9 +1100,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
         }
         "delcontact" => {
             ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
-            if !dc_delete_contact(context, arg1.parse()?) {
-                bail!("Failed to delete contact");
-            }
+            Contact::delete(context, arg1.parse()?)?;
         }
         "checkqr" => {
             ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");

examples/repl/main.rs

@@ -291,7 +291,7 @@ const DB_COMMANDS: [&'static str; 11] = [
     "housekeeping",
 ];
 
-const CHAT_COMMANDS: [&'static str; 25] = [
+const CHAT_COMMANDS: [&'static str; 24] = [
     "listchats",
     "listarchived",
     "chat",
@@ -309,7 +309,6 @@ const CHAT_COMMANDS: [&'static str; 25] = [
     "dellocations",
     "getlocations",
     "send",
-    "send-garbage",
     "sendimage",
     "sendfile",
     "draft",
@@ -336,8 +335,8 @@ const CONTACT_COMMANDS: [&'static str; 6] = [
     "delcontact",
     "cleanupcontacts",
 ];
-const MISC_COMMANDS: [&'static str; 8] = [
-    "getqr", "getbadqr", "checkqr", "event", "fileinfo", "clear", "exit", "help",
+const MISC_COMMANDS: [&'static str; 9] = [
+    "getqr", "getbadqr", "checkqr", "event", "fileinfo", "clear", "exit", "quit", "help",
 ];
 
 impl Hinter for DcHelper {
@@ -457,12 +456,6 @@ fn main_0(args: Vec<String>) -> Result<(), failure::Error> {
     println!("history saved");
     {
         stop_threads(&ctx.read().unwrap());
-
-        unsafe {
-            let mut ctx = ctx.write().unwrap();
-            dc_close(&mut ctx);
-            dc_context_unref(&mut ctx);
-        }
     }
 
     Ok(())
@@ -557,7 +550,7 @@ unsafe fn handle_cmd(line: &str, ctx: Arc<RwLock<Context>>) -> Result<ExitResult
                 dc_join_securejoin(&ctx.read().unwrap(), arg1_c);
             }
         }
-        "exit" => return Ok(ExitResult::Exit),
+        "exit" | "quit" => return Ok(ExitResult::Exit),
         _ => dc_cmdline(&ctx.read().unwrap(), line)?,
     }
 

examples/simple.rs

@@ -1,6 +1,6 @@
 extern crate deltachat;
 
-use std::ffi::{CStr, CString};
+use std::ffi::CStr;
 use std::sync::{Arc, RwLock};
 use std::{thread, time};
 use tempfile::tempdir;
@@ -8,10 +8,10 @@ use tempfile::tempdir;
 use deltachat::chatlist::*;
 use deltachat::config;
 use deltachat::constants::Event;
+use deltachat::contact::*;
 use deltachat::context::*;
 use deltachat::dc_chat::*;
 use deltachat::dc_configure::*;
-use deltachat::dc_contact::*;
 use deltachat::dc_job::{
     dc_perform_imap_fetch, dc_perform_imap_idle, dc_perform_imap_jobs, dc_perform_smtp_idle,
     dc_perform_smtp_jobs,
@@ -93,12 +93,11 @@ fn main() {
 
         thread::sleep(duration);
 
-        let email = CString::new("dignifiedquire@gmail.com").unwrap();
         println!("sending a message");
-        let contact_id = dc_create_contact(&ctx, std::ptr::null(), email.as_ptr());
+        let contact_id =
+            Contact::create(&ctx, "dignifiedquire", "dignifiedquire@gmail.com").unwrap();
         let chat_id = dc_create_chat_by_contact_id(&ctx, contact_id);
-        let msg_text = CString::new("Hi, here is my first message!").unwrap();
-        dc_send_text_msg(&ctx, chat_id, msg_text.as_ptr());
+        dc_send_text_msg(&ctx, chat_id, "Hi, here is my first message!".into());
 
         println!("fetching chats..");
         let chats = Chatlist::try_load(&ctx, 0, None, None).unwrap();

python/README.rst

@@ -15,7 +15,7 @@ without any "build-from-source" steps.
 1. `Install virtualenv <https://virtualenv.pypa.io/en/stable/installation/>`_,
    then create a fresh python environment and activate it in your shell::
 
-        virtualenv -p python3 venv
+        virtualenv venv  # or: python -m venv
         source venv/bin/activate
 
    Afterwards, invoking ``python`` or ``pip install`` will only
@@ -39,6 +39,12 @@ and push them to a python package index. To install the latest github ``master``
 
     pip install -i https://m.devpi.net/dc/master deltachat
 
+.. note::
+
+    If you can help to automate the building of wheels for Mac or Windows,
+    that'd be much appreciated! please then get
+    `in contact with us <https://delta.chat/en/contribute>`_.
+
 
 Installing bindings from source
 ===============================
@@ -48,34 +54,55 @@ to core deltachat library::
 
     git clone https://github.com/deltachat/deltachat-core-rust
     cd deltachat-core-rust
-    cargo build -p deltachat_ffi --release
-
-This will result in a ``libdeltachat.so`` and ``libdeltachat.a`` files
-in the ``target/release`` directory. These files are needed for
-creating the python bindings for deltachat::
-
     cd python
-    DCC_RS_DEV=`pwd`/.. pip install -e .
 
-Now test if the bindings find the correct library::
+If you don't have one active, create and activate a python "virtualenv":
 
-    python -c 'import deltachat ; print(deltachat.__version__)'
+    python virtualenv venv  # or python -m venv
+    source venv/bin/activate
 
-This should print your deltachat bindings version.
+Afterwards ``which python`` tells you that it comes out of the "venv"
+directory that contains all python install artifacts. Let's first
+install test tools::
+
+    pip install pytest pytest-timeout requests
+
+then cargo-build and install the deltachat bindings::
+
+    python install_python_bindings.py
+
+The bindings will be installed in release mode but with debug symbols.
+The release mode is neccessary because some tests generate RSA keys
+which is prohibitively slow in debug mode.
+
+After succcessul binding installation you can finally run the tests::
+
+    pytest -v tests
 
 .. note::
 
-    If you can help to automate the building of wheels for Mac or Windows,
-    that'd be much appreciated! please then get
-    `in contact with us <https://delta.chat/en/contribute>`_.
+    Some tests are sometimes failing/hanging because of
+    https://github.com/deltachat/deltachat-core-rust/issues/331
+    and
+    https://github.com/deltachat/deltachat-core-rust/issues/326
 
-Using a system-installed deltachat-core-rust
---------------------------------------------
 
-When calling ``pip`` without specifying the ``DCC_RS_DEV`` environment
-variable cffi will try to use a ``deltachat.h`` from a system location
-like ``/usr/local/include`` and will try to dynamically link against a
-``libdeltachat.so`` in a similar location (e.g. ``/usr/local/lib``).
+running "live" tests (experimental)
+-----------------------------------
+
+If you want to run "liveconfig" functional tests you can set
+``DCC_PY_LIVECONFIG`` to:
+
+- a particular https-url that you can ask for from the delta
+  chat devs.
+
+- or the path of a file that contains two lines, each describing
+  via "addr=... mail_pwd=..." a test account login that will
+  be used for the live tests.
+
+With ``DCC_PY_LIVECONFIG`` set pytest invocations will use real
+e-mail accounts and run through all functional "liveconfig" tests.
+
 
 
 Code examples
@@ -84,68 +111,34 @@ Code examples
 You may look at `examples <https://py.delta.chat/examples.html>`_.
 
 
-Running tests
-=============
-
-Get a checkout of the `deltachat-core-rust github repository`_ and type::
-
-    pip install tox
-    ./run-integration-tests.sh
-
-If you want to run functional tests with real
-e-mail test accounts, generate a "liveconfig" file where each
-lines contains test account settings, for example::
-
-    # 'liveconfig' file specifying imap/smtp accounts
-    addr=some-email@example.org mail_pw=password
-    addr=other-email@example.org mail_pw=otherpassword
-
-The "keyword=value" style allows to specify any
-`deltachat account config setting <https://c.delta.chat/classdc__context__t.html#aff3b894f6cfca46cab5248fdffdf083d>`_ so you can also specify smtp or imap servers, ports, ssl modes etc.
-Typically DC's automatic configuration allows to not specify these settings.
-
-The ``run-integration-tests.sh`` script will automatically use
-``python/liveconfig`` if it exists, to manually run tests with this
-``liveconfig`` file use::
-
-    tox -- --liveconfig liveconfig
-
-
 .. _`deltachat-core-rust github repository`: https://github.com/deltachat/deltachat-core-rust
 .. _`deltachat-core`: https://github.com/deltachat/deltachat-core-rust
 
-Running test using a debug build
---------------------------------
-
-If you need to examine e.g. a coredump you may want to run the tests
-using a debug build::
-
-   DCC_RS_TARGET=debug ./run-integration-tests.sh -e py37 -- -x -v -k failing_test
-
 
 Building manylinux1 wheels
 ==========================
 
+.. note::
+
+   This section may not fully work.
+
 Building portable manylinux1 wheels which come with libdeltachat.so
 and all it's dependencies is easy using the provided docker tooling.
 
 using docker pull / premade images
 ------------------------------------
 
-We publish a build environment under the ``deltachat/wheel`` tag so
+We publish a build environment under the ``deltachat/coredeps`` tag so
 that you can pull it from the ``hub.docker.com`` site's "deltachat"
 organization::
 
-    $ docker pull deltachat/wheel
+    $ docker pull deltachat/coredeps
 
-The ``deltachat/wheel`` image can be used to build both libdeltachat.so
-and the Python wheels::
+This docker image can be used to run tests and build Python wheels for all interpreters::
 
-    $ docker run --rm -it -v $(pwd):/io/ deltachat/wheel /io/python/wheelbuilder/build-wheels.sh
+    $ bash ci_scripts/ci_run.sh
 
-This command runs a script within the image, after mounting ``$(pwd)`` as ``/io`` within
-the docker image.  The script is specified as a path within the docker image's filesystem.
-The resulting wheel files will be in ``python/wheelhouse``.
+This command runs tests and build-wheel scripts in a docker container.
 
 
 Optionally build your own docker image
@@ -154,10 +147,10 @@ Optionally build your own docker image
 If you want to build your own custom docker image you can do this::
 
    $ cd deltachat-core # cd to deltachat-core checkout directory
-   $ docker build -t deltachat/wheel python/wheelbuilder/
+   $ docker build -t deltachat/coredeps ci_scripts/docker_coredeps
 
-This will use the ``python/wheelbuilder/Dockerfile`` to build
-up docker image called ``deltachat/wheel``.  You can afterwards
+This will use the ``ci_scripts/docker_coredeps/Dockerfile`` to build
+up docker image called ``deltachat/coredeps``.  You can afterwards
 find it with::
 
    $ docker images

python/install_python_bindings.py

@@ -6,29 +6,18 @@
 
 import os
 import subprocess
+import os
 
 if __name__ == "__main__":
     os.environ["DCC_RS_TARGET"] = target = "release"
+    if "DCC_RS_DEV" not in os.environ:
+        dn = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        os.environ["DCC_RS_DEV"] = dn
 
-    toml = os.path.join(os.getcwd(), "..", "Cargo.toml")
-    assert os.path.exists(toml)
-    with open(toml) as f:
-        s = orig = f.read()
-    s += "\n"
-    s += "[profile.release]\n"
-    s += "debug = true\n"
-    with open(toml, "w") as f:
-        f.write(s)
-    print("temporarily modifying Cargo.toml to provide release build with debug symbols ")
-    try:
-        subprocess.check_call([
-            "cargo", "build", "-p", "deltachat_ffi", "--" + target
-        ])
-    finally:
-        with open(toml, "w") as f:
-            f.write(orig)
-        print("\nreseted Cargo.toml to previous original state")
-
+    os.environ["RUSTFLAGS"] = "-g"
+    subprocess.check_call([
+        "cargo", "build", "-p", "deltachat_ffi", "--" + target
+    ])
     subprocess.check_call("rm -rf build/ src/deltachat/*.so" , shell=True)
 
     subprocess.check_call([

python/src/deltachat/_build.py

@@ -6,10 +6,15 @@ import platform
 import os
 import cffi
 import shutil
+from os.path import dirname as dn
+from os.path import abspath
 
 
 def ffibuilder():
     projdir = os.environ.get('DCC_RS_DEV')
+    if not projdir:
+        p = dn(dn(dn(dn(abspath(__file__)))))
+        projdir = os.environ["DCC_RS_DEV"] = p
     target = os.environ.get('DCC_RS_TARGET', 'release')
     if projdir:
         if platform.system() == 'Darwin':

python/src/deltachat/account.py

@@ -50,8 +50,9 @@ class Account(object):
         self._configkeys = self.get_config("sys.config_keys").split()
         self._imex_completed = threading.Event()
 
-    def __del__(self):
-        self.shutdown()
+    # XXX this can cause "illegal instructions" at test ends so we omit it for now
+    # def __del__(self):
+    #    self.shutdown()
 
     def _check_config_key(self, name):
         if name not in self._configkeys:

python/tests/conftest.py

@@ -1,9 +1,9 @@
 from __future__ import print_function
 import os
 import pytest
+import requests
 import time
 from deltachat import Account
-from deltachat import props
 from deltachat.capi import lib
 import tempfile
 
@@ -36,6 +36,8 @@ def pytest_runtest_call(item):
 
 
 def pytest_report_header(config, startdir):
+    summary = []
+
     t = tempfile.mktemp()
     try:
         ac = Account(t, eventlogging=False)
@@ -43,13 +45,18 @@ def pytest_report_header(config, startdir):
         ac.shutdown()
     finally:
         os.remove(t)
-    summary = ['Deltachat core={} sqlite={}'.format(
+    summary.extend(['Deltachat core={} sqlite={}'.format(
          info['deltachat_core_version'],
          info['sqlite_version'],
-     )]
-    cfg = config.getoption('--liveconfig')
+     )])
+
+    cfg = config.option.liveconfig
     if cfg:
-        summary.append('Liveconfig: {}'.format(os.path.abspath(cfg)))
+        if "#" in cfg:
+            url, token = cfg.split("#", 1)
+            summary.append('Liveconfig provider: {}#<token ommitted>'.format(url))
+        else:
+            summary.append('Liveconfig file: {}'.format(cfg))
     return summary
 
 
@@ -66,9 +73,56 @@ def data():
     return Data()
 
 
+class SessionLiveConfigFromFile:
+    def __init__(self, fn):
+        self.fn = fn
+        self.configlist = []
+        for line in open(fn):
+            if line.strip() and not line.strip().startswith('#'):
+                d = {}
+                for part in line.split():
+                    name, value = part.split("=")
+                    d[name] = value
+                self.configlist.append(d)
+
+    def get(self, index):
+        return self.configlist[index]
+
+    def exists(self):
+        return bool(self.configlist)
+
+
+class SessionLiveConfigFromURL:
+    def __init__(self, url, create_token):
+        self.configlist = []
+        for i in range(2):
+            res = requests.post(url, json={"token_create_user": int(create_token)})
+            if res.status_code != 200:
+                pytest.skip("creating newtmpuser failed {!r}".format(res))
+            d = res.json()
+            config = dict(addr=d["email"], mail_pw=d["password"])
+            self.configlist.append(config)
+
+    def get(self, index):
+        return self.configlist[index]
+
+    def exists(self):
+        return bool(self.configlist)
+
+
+@pytest.fixture(scope="session")
+def session_liveconfig(request):
+    liveconfig_opt = request.config.option.liveconfig
+    if liveconfig_opt:
+        if liveconfig_opt.startswith("http"):
+            url, create_token = liveconfig_opt.split("#", 1)
+            return SessionLiveConfigFromURL(url, create_token)
+        else:
+            return SessionLiveConfigFromFile(liveconfig_opt)
+
+
 @pytest.fixture
-def acfactory(pytestconfig, tmpdir, request):
-    fn = pytestconfig.getoption("--liveconfig")
+def acfactory(pytestconfig, tmpdir, request, session_liveconfig):
 
     class AccountMaker:
         def __init__(self):
@@ -82,18 +136,6 @@ def acfactory(pytestconfig, tmpdir, request):
                 fin = self._finalizers.pop()
                 fin()
 
-        @props.cached
-        def configlist(self):
-            configlist = []
-            for line in open(fn):
-                if line.strip() and not line.strip().startswith('#'):
-                    d = {}
-                    for part in line.split():
-                        name, value = part.split("=")
-                        d[name] = value
-                    configlist.append(d)
-            return configlist
-
         def get_unconfigured_account(self):
             self.offline_count += 1
             tmpdb = tmpdir.join("offlinedb%d" % self.offline_count)
@@ -116,10 +158,12 @@ def acfactory(pytestconfig, tmpdir, request):
             return ac
 
         def get_online_configuring_account(self):
-            if not fn:
-                pytest.skip("specify a --liveconfig file to run tests with real accounts")
+            if not session_liveconfig:
+                pytest.skip("specify DCC_PY_LIVECONFIG or --liveconfig")
+            configdict = session_liveconfig.get(self.live_count)
             self.live_count += 1
-            configdict = self.configlist.pop(0)
+            if "e2ee_enabled" not in configdict:
+                configdict["e2ee_enabled"] = "1"
             tmpdb = tmpdir.join("livedb%d" % self.live_count)
             ac = Account(tmpdb.strpath, logid="ac{}".format(self.live_count))
             ac._evlogger.init_time = self.init_time

python/tests/test_account.py

@@ -421,10 +421,43 @@ class TestOnlineAccount:
         lp.sec("mark message as seen on ac2, wait for changes on ac1")
         ac2.mark_seen_messages([msg_in])
         lp.step("1")
-        ac1._evlogger.get_matching("DC_EVENT_MSG_READ")
+        ev = ac1._evlogger.get_matching("DC_EVENT_MSG_READ")
+        assert ev[1] >= const.DC_CHAT_ID_LAST_SPECIAL
+        assert ev[2] >= const.DC_MSG_ID_LAST_SPECIAL
         lp.step("2")
         assert msg_out.is_out_mdn_received()
 
+    def test_send_and_receive_will_encrypt_decrypt(self, acfactory, lp):
+        lp.sec("starting accounts, waiting for configuration")
+        ac1 = acfactory.get_online_configuring_account()
+        ac2 = acfactory.get_online_configuring_account()
+        c2 = ac1.create_contact(email=ac2.get_config("addr"))
+        chat = ac1.create_chat_by_contact(c2)
+        assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
+
+        wait_configuration_progress(ac1, 1000)
+        wait_configuration_progress(ac2, 1000)
+
+        lp.sec("sending text message from ac1 to ac2")
+        msg_out = chat.send_text("message1")
+
+        lp.sec("wait for ac2 to receive message")
+        ev = ac2._evlogger.get_matching("DC_EVENT_MSGS_CHANGED")
+        assert ev[2] == msg_out.id
+        msg_in = ac2.get_message_by_id(msg_out.id)
+        assert msg_in.text == "message1"
+
+        lp.sec("create new chat with contact and send back (encrypted) message")
+        chat2b = ac2.create_chat_by_message(msg_in)
+        chat2b.send_text("message-back")
+
+        lp.sec("wait for ac1 to receive message")
+        ev = ac1._evlogger.get_matching("DC_EVENT_INCOMING_MSG")
+        assert ev[1] == chat.id
+        assert ev[2] > msg_out.id
+        msg_back = ac1.get_message_by_id(ev[2])
+        assert msg_back.text == "message-back"
+
     def test_saved_mime_on_received_message(self, acfactory, lp):
         lp.sec("starting accounts, waiting for configuration")
         ac1 = acfactory.get_online_configuring_account()

python/tox.ini

@@ -19,6 +19,7 @@ deps =
     pytest
     pytest-faulthandler
     pdbpp
+    requests
 
 [testenv:auditwheels]
 skipsdist = True
@@ -51,6 +52,7 @@ commands =
 
 
 [pytest]
+addopts = -v -rs
 python_files = tests/test_*.py 
 norecursedirs = .tox 
 xfail_strict=true

run-integration-tests.sh

@@ -23,7 +23,7 @@ if [ $? != 0 ]; then
 fi
 
 pushd python
-if [ -e "./liveconfig" ]; then
+if [ -e "./liveconfig" && -z "$DCC_PY_LIVECONFIG" ]; then
     export DCC_PY_LIVECONFIG=liveconfig
 fi
 tox "$@"

src/aheader.rs

@@ -6,7 +6,7 @@ use std::{fmt, str};
 use mmime::mailimf_types::*;
 
 use crate::constants::*;
-use crate::dc_contact::*;
+use crate::contact::*;
 use crate::dc_tools::as_str;
 use crate::key::*;
 
@@ -94,7 +94,7 @@ impl Aheader {
 
                     match Self::from_str(value) {
                         Ok(test) => {
-                            if dc_addr_cmp(&test.addr, as_str(wanted_from)) {
+                            if addr_cmp(&test.addr, as_str(wanted_from)) {
                                 if fine_header.is_none() {
                                     fine_header = Some(test);
                                 } else {

src/chatlist.rs

@@ -1,7 +1,7 @@
 use crate::constants::*;
+use crate::contact::*;
 use crate::context::*;
 use crate::dc_chat::*;
-use crate::dc_contact::*;
 use crate::dc_lot::*;
 use crate::dc_msg::*;
 use crate::dc_tools::*;
@@ -261,7 +261,7 @@ impl<'a> Chatlist<'a> {
         }
 
         let lastmsg_id = self.ids[index].1;
-        let mut lastcontact = 0 as *mut dc_contact_t;
+        let mut lastcontact = None;
 
         if chat.is_null() {
             chat = dc_chat_new(self.context);
@@ -282,8 +282,7 @@ impl<'a> Chatlist<'a> {
                 && ((*chat).type_0 == DC_CHAT_TYPE_GROUP
                     || (*chat).type_0 == DC_CHAT_TYPE_VERIFIED_GROUP)
             {
-                lastcontact = dc_contact_new(self.context);
-                dc_contact_load_from_db(lastcontact, &self.context.sql, (*lastmsg).from_id);
+                lastcontact = Contact::load_from_db(self.context, (*lastmsg).from_id).ok();
             }
             lastmsg
         } else {
@@ -292,14 +291,13 @@ impl<'a> Chatlist<'a> {
 
         if (*chat).id == DC_CHAT_ID_ARCHIVED_LINK as u32 {
             (*ret).text2 = dc_strdup(0 as *const libc::c_char)
-        } else if lastmsg.is_null() || (*lastmsg).from_id == DC_CONTACT_ID_SELF as u32 {
+        } else if lastmsg.is_null() || (*lastmsg).from_id == DC_CONTACT_ID_UNDEFINED as u32 {
             (*ret).text2 = self.context.stock_str(StockMessage::NoMessages).strdup();
         } else {
-            dc_lot_fill(ret, lastmsg, chat, lastcontact, self.context);
+            dc_lot_fill(ret, lastmsg, chat, lastcontact.as_ref(), self.context);
         }
 
         dc_msg_unref(lastmsg);
-        dc_contact_unref(lastcontact);
 
         ret
     }

src/config.rs

@@ -1,5 +1,3 @@
-use std::ffi::CString;
-
 use strum::{EnumProperty, IntoEnumIterator};
 use strum_macros::{AsRefStr, Display, EnumIter, EnumProperty, EnumString};
 
@@ -9,7 +7,6 @@ use crate::dc_job::*;
 use crate::dc_tools::*;
 use crate::error::Error;
 use crate::stock::StockMessage;
-use crate::x::*;
 
 /// The available configuration keys.
 #[derive(
@@ -72,15 +69,7 @@ impl Context {
         let value = match key {
             Config::Selfavatar => {
                 let rel_path = self.sql.get_config(self, key);
-                rel_path.map(|p| {
-                    let v = unsafe {
-                        let n = CString::yolo(p);
-                        dc_get_abs_path(self, n.as_ptr())
-                    };
-                    let r = to_string(v);
-                    unsafe { free(v as *mut _) };
-                    r
-                })
+                rel_path.map(|p| dc_get_abs_path_safe(self, &p).to_str().unwrap().to_string())
             }
             Config::SysVersion => Some(std::str::from_utf8(DC_VERSION_STR).unwrap().into()),
             Config::SysMsgsizeMaxRecommended => Some(format!("{}", 24 * 1024 * 1024 / 4 * 3)),

src/constants.rs

@@ -1,15 +1,35 @@
 //! Constants
 #![allow(non_camel_case_types)]
-use num_traits::{FromPrimitive, ToPrimitive};
-use rusqlite as sql;
-use rusqlite::types::*;
+use deltachat_derive::*;
 
 pub const DC_VERSION_STR: &'static [u8; 14] = b"1.0.0-alpha.3\x00";
 
-pub const DC_MOVE_STATE_MOVING: u32 = 3;
-pub const DC_MOVE_STATE_STAY: u32 = 2;
-pub const DC_MOVE_STATE_PENDING: u32 = 1;
-pub const DC_MOVE_STATE_UNDEFINED: u32 = 0;
+#[repr(u8)]
+#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, ToSql, FromSql)]
+pub enum MoveState {
+    Undefined = 0,
+    Pending = 1,
+    Stay = 2,
+    Moving = 3,
+}
+
+// some defaults
+pub const DC_E2EE_DEFAULT_ENABLED: i32 = 1;
+pub const DC_MDNS_DEFAULT_ENABLED: i32 = 1;
+pub const DC_INBOX_WATCH_DEFAULT: i32 = 1;
+pub const DC_SENTBOX_WATCH_DEFAULT: i32 = 1;
+pub const DC_MVBOX_WATCH_DEFAULT: i32 = 1;
+pub const DC_MVBOX_MOVE_DEFAULT: i32 = 1;
+
+pub const DC_CHAT_NOT_BLOCKED: i32 = 0;
+pub const DC_CHAT_MANUALLY_BLOCKED: i32 = 1;
+pub const DC_CHAT_DEADDROP_BLOCKED: i32 = 2;
+
+pub const DC_IMAP_SEEN: u32 = 0x1;
+
+pub const DC_HANDSHAKE_CONTINUE_NORMAL_PROCESSING: i32 = 0x01;
+pub const DC_HANDSHAKE_STOP_NORMAL_PROCESSING: i32 = 0x02;
+pub const DC_HANDSHAKE_ADD_DELETE_JOB: i32 = 0x04;
 
 pub const DC_GCL_ARCHIVED_ONLY: usize = 0x01;
 pub const DC_GCL_NO_SPECIALS: usize = 0x02;
@@ -89,6 +109,7 @@ pub const DC_MAX_GET_TEXT_LEN: usize = 30000;
 /// approx. max. length returned by dc_get_msg_info()
 pub const DC_MAX_GET_INFO_LEN: usize = 100000;
 
+pub const DC_CONTACT_ID_UNDEFINED: usize = 0;
 pub const DC_CONTACT_ID_SELF: usize = 1;
 pub const DC_CONTACT_ID_DEVICE: usize = 2;
 pub const DC_CONTACT_ID_LAST_SPECIAL: usize = 9;
@@ -146,7 +167,7 @@ pub const DC_LP_IMAP_SOCKET_FLAGS: usize =
 pub const DC_LP_SMTP_SOCKET_FLAGS: usize =
     (DC_LP_SMTP_SOCKET_STARTTLS | DC_LP_SMTP_SOCKET_SSL | DC_LP_SMTP_SOCKET_PLAIN);
 
-#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, FromSql, ToSql)]
 #[repr(i32)]
 pub enum Viewtype {
     Unknown = 0,
@@ -201,23 +222,6 @@ mod tests {
     }
 }
 
-impl ToSql for Viewtype {
-    fn to_sql(&self) -> sql::Result<ToSqlOutput> {
-        let num: i64 = self
-            .to_i64()
-            .expect("impossible: Viewtype -> i64 conversion failed");
-
-        Ok(ToSqlOutput::Owned(Value::Integer(num)))
-    }
-}
-
-impl FromSql for Viewtype {
-    fn column_result(col: ValueRef) -> FromSqlResult<Self> {
-        let inner = FromSql::column_result(col)?;
-        FromPrimitive::from_i64(inner).ok_or(FromSqlError::InvalidType)
-    }
-}
-
 // These constants are used as events
 // reported to the callback given to dc_context_new().
 // If you do not want to handle an event, it is always safe to return 0,

src/context.rs

@@ -1,9 +1,9 @@
 use std::sync::{Arc, Condvar, Mutex, RwLock};
 
 use crate::constants::*;
+use crate::contact::*;
 use crate::dc_array::*;
 use crate::dc_chat::*;
-use crate::dc_contact::*;
 use crate::dc_job::*;
 use crate::dc_jobthread::*;
 use crate::dc_loginparam::*;
@@ -20,7 +20,6 @@ use crate::sql::Sql;
 use crate::types::*;
 use crate::x::*;
 
-#[repr(C)]
 pub struct Context {
     pub userdata: *mut libc::c_void,
     pub dbfile: Arc<RwLock<*mut libc::c_char>>,
@@ -40,6 +39,8 @@ pub struct Context {
     pub bob: Arc<RwLock<BobStatus>>,
     pub last_smeared_timestamp: Arc<RwLock<i64>>,
     pub running_state: Arc<RwLock<RunningState>>,
+    /// Mutex to avoid generating the key for the user more than once.
+    pub generating_key_mutex: Mutex<()>,
 }
 
 unsafe impl std::marker::Send for Context {}
@@ -77,6 +78,14 @@ impl Context {
     }
 }
 
+impl Drop for Context {
+    fn drop(&mut self) {
+        unsafe {
+            dc_close(&self);
+        }
+    }
+}
+
 impl Default for RunningState {
     fn default() -> Self {
         RunningState {
@@ -162,16 +171,7 @@ pub fn dc_context_new(
         ))),
         probe_imap_network: Arc::new(RwLock::new(false)),
         perform_inbox_jobs_needed: Arc::new(RwLock::new(false)),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn no_crashes_on_context_deref() {
-        let mut ctx = dc_context_new(None, std::ptr::null_mut(), Some("Test OS".into()));
-        unsafe { dc_context_unref(&mut ctx) };
+        generating_key_mutex: Mutex::new(()),
     }
 }
 
@@ -229,7 +229,7 @@ unsafe fn cb_precheck_imf(
                 "[move] detected moved message {}",
                 as_str(rfc724_mid),
             );
-            dc_update_msg_move_state(context, rfc724_mid, DC_MOVE_STATE_STAY);
+            dc_update_msg_move_state(context, rfc724_mid, MoveState::Stay);
         }
         if as_str(old_server_folder) != server_folder || old_server_uid != server_uid {
             dc_update_server_uid(context, rfc724_mid, server_folder, server_uid);
@@ -258,12 +258,6 @@ fn cb_get_config(context: &Context, key: &str) -> Option<String> {
     context.sql.get_config(context, key)
 }
 
-pub unsafe fn dc_context_unref(context: &mut Context) {
-    if 0 != dc_is_open(context) {
-        dc_close(context);
-    }
-}
-
 pub unsafe fn dc_close(context: &Context) {
     info!(context, 0, "disconnecting INBOX-watch",);
     context.inbox.read().unwrap().disconnect(context);
@@ -315,9 +309,9 @@ pub unsafe fn dc_open(context: &Context, dbfile: &str, blobdir: Option<&str>) ->
         let dir = dc_ensure_no_slash_safe(blobdir.unwrap()).strdup();
         *context.blobdir.write().unwrap() = dir;
     } else {
-        let dir = (dbfile.to_string() + "-blobs").strdup();
-        dc_create_folder(context, dir);
-        *context.blobdir.write().unwrap() = dir;
+        let dir = dbfile.to_string() + "-blobs";
+        dc_create_folder(context, &dir);
+        *context.blobdir.write().unwrap() = dir.strdup();
     }
     // Create/open sqlite database, this may already use the blobdir
     let dbfile_path = std::path::Path::new(dbfile);
@@ -346,7 +340,7 @@ pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
     let chats = dc_get_chat_cnt(context) as usize;
     let real_msgs = dc_get_real_msg_cnt(context) as usize;
     let deaddrop_msgs = dc_get_deaddrop_msg_cnt(context) as usize;
-    let contacts = dc_get_real_contact_cnt(context) as usize;
+    let contacts = Contact::get_real_cnt(context) as usize;
     let is_configured = context
         .sql
         .get_config_int(context, "configured")
@@ -505,13 +499,12 @@ pub fn dc_get_fresh_msgs(context: &Context) -> *mut dc_array_t {
             &[10, 9, if 0 != show_deaddrop { 2 } else { 0 }],
             |row| row.get(0),
             |rows| {
-                let mut ret = dc_array_t::new(128);
-
+                let mut ret = Vec::new();
                 for row in rows {
-                    let id = row?;
-                    ret.add_id(id);
+                    let id: u32 = row?;
+                    ret.push(id);
                 }
-                Ok(ret.into_raw())
+                Ok(dc_array_t::from(ret).into_raw())
             },
         )
         .unwrap()
@@ -545,7 +538,7 @@ pub fn dc_search_msgs(
          AND ct.blocked=0 AND (m.txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp DESC,m.id DESC;"
     };
 
-    let mut ret = dc_array_t::new(100);
+    let mut ret = Vec::new();
 
     let success = context
         .sql
@@ -555,7 +548,7 @@ pub fn dc_search_msgs(
             |row| row.get::<_, i32>(0),
             |rows| {
                 for id in rows {
-                    ret.add_id(id? as u32);
+                    ret.push(id? as u32);
                 }
                 Ok(())
             },
@@ -563,7 +556,7 @@ pub fn dc_search_msgs(
         .is_ok();
 
     if success {
-        return ret.into_raw();
+        return dc_array_t::from(ret).into_raw();
     }
 
     std::ptr::null_mut()
@@ -591,3 +584,24 @@ pub fn dc_is_mvbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
         false
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn no_crashes_on_context_deref() {
+        let ctx = dc_context_new(None, std::ptr::null_mut(), Some("Test OS".into()));
+        std::mem::drop(ctx);
+    }
+
+    #[test]
+    fn test_context_double_close() {
+        let ctx = dc_context_new(None, std::ptr::null_mut(), None);
+        unsafe {
+            dc_close(&ctx);
+            dc_close(&ctx);
+        }
+        std::mem::drop(ctx);
+    }
+}

src/dc_array.rs

@@ -147,6 +147,12 @@ impl dc_array_t {
     }
 }
 
+impl From<Vec<u32>> for dc_array_t {
+    fn from(array: Vec<u32>) -> Self {
+        dc_array_t::Uint(array.iter().map(|&x| x as uintptr_t).collect())
+    }
+}
+
 impl From<Vec<dc_location>> for dc_array_t {
     fn from(array: Vec<dc_location>) -> Self {
         dc_array_t::Locations(array)
@@ -154,22 +160,18 @@ impl From<Vec<dc_location>> for dc_array_t {
 }
 
 pub unsafe fn dc_array_unref(array: *mut dc_array_t) {
-    if array.is_null() {
-        return;
-    }
+    assert!(!array.is_null());
     Box::from_raw(array);
 }
 
 pub unsafe fn dc_array_add_uint(array: *mut dc_array_t, item: uintptr_t) {
-    if !array.is_null() {
-        (*array).add_uint(item);
-    }
+    assert!(!array.is_null());
+    (*array).add_uint(item);
 }
 
 pub unsafe fn dc_array_add_id(array: *mut dc_array_t, item: uint32_t) {
-    if !array.is_null() {
-        (*array).add_id(item);
-    }
+    assert!(!array.is_null());
+    (*array).add_id(item);
 }
 
 pub unsafe fn dc_array_add_ptr(array: *mut dc_array_t, item: *mut libc::c_void) {
@@ -177,97 +179,62 @@ pub unsafe fn dc_array_add_ptr(array: *mut dc_array_t, item: *mut libc::c_void)
 }
 
 pub unsafe fn dc_array_get_cnt(array: *const dc_array_t) -> size_t {
-    if array.is_null() {
-        0
-    } else {
-        (*array).len()
-    }
+    assert!(!array.is_null());
+    (*array).len()
 }
 
 pub unsafe fn dc_array_get_uint(array: *const dc_array_t, index: size_t) -> uintptr_t {
-    if array.is_null() || index >= (*array).len() {
-        0
-    } else {
-        (*array).get_uint(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_uint(index)
 }
 
 pub unsafe fn dc_array_get_id(array: *const dc_array_t, index: size_t) -> uint32_t {
-    if array.is_null() || index >= (*array).len() {
-        0
-    } else {
-        (*array).get_id(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_id(index)
 }
 
 pub unsafe fn dc_array_get_ptr(array: *const dc_array_t, index: size_t) -> *mut libc::c_void {
-    if array.is_null() || index >= (*array).len() {
-        std::ptr::null_mut()
-    } else {
-        (*array).get_ptr(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_ptr(index)
 }
 
 pub unsafe fn dc_array_get_latitude(array: *const dc_array_t, index: size_t) -> libc::c_double {
-    if array.is_null() || index >= (*array).len() {
-        0.0
-    } else {
-        (*array).get_latitude(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_latitude(index)
 }
 
 pub unsafe fn dc_array_get_longitude(array: *const dc_array_t, index: size_t) -> libc::c_double {
-    if array.is_null() || index >= (*array).len() {
-        0.0
-    } else {
-        (*array).get_longitude(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_longitude(index)
 }
 
 pub unsafe fn dc_array_get_accuracy(array: *const dc_array_t, index: size_t) -> libc::c_double {
-    if array.is_null() || index >= (*array).len() {
-        0.0
-    } else {
-        (*array).get_accuracy(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_accuracy(index)
 }
 
 pub unsafe fn dc_array_get_timestamp(array: *const dc_array_t, index: size_t) -> i64 {
-    if array.is_null() || index >= (*array).len() {
-        0
-    } else {
-        (*array).get_timestamp(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_timestamp(index)
 }
 
 pub unsafe fn dc_array_get_chat_id(array: *const dc_array_t, index: size_t) -> uint32_t {
-    if array.is_null() || index >= (*array).len() {
-        0
-    } else {
-        (*array).get_chat_id(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_chat_id(index)
 }
 
 pub unsafe fn dc_array_get_contact_id(array: *const dc_array_t, index: size_t) -> uint32_t {
-    if array.is_null() || index >= (*array).len() {
-        0
-    } else {
-        (*array).get_contact_id(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_contact_id(index)
 }
 
 pub unsafe fn dc_array_get_msg_id(array: *const dc_array_t, index: size_t) -> uint32_t {
-    if array.is_null() || index >= (*array).len() {
-        0
-    } else {
-        (*array).get_msg_id(index)
-    }
+    assert!(!array.is_null());
+    (*array).get_msg_id(index)
 }
 
 pub unsafe fn dc_array_get_marker(array: *const dc_array_t, index: size_t) -> *mut libc::c_char {
-    if array.is_null() || index >= (*array).len() {
-        return std::ptr::null_mut();
-    }
+    assert!(!array.is_null());
 
     if let dc_array_t::Locations(v) = &*array {
         if let Some(s) = &v[index].marker {
@@ -276,7 +243,7 @@ pub unsafe fn dc_array_get_marker(array: *const dc_array_t, index: size_t) -> *m
             std::ptr::null_mut()
         }
     } else {
-        std::ptr::null_mut()
+        panic!("Not an array of locations");
     }
 }
 
@@ -291,9 +258,7 @@ pub unsafe fn dc_array_get_marker(array: *const dc_array_t, index: size_t) -> *m
  *     1=Location was reported independently.
  */
 pub unsafe fn dc_array_is_independent(array: *const dc_array_t, index: size_t) -> libc::c_int {
-    if array.is_null() || index >= (*array).len() {
-        return 0;
-    }
+    assert!(!array.is_null());
 
     if let dc_array_t::Locations(v) = &*array {
         v[index].independent as libc::c_int
@@ -307,9 +272,8 @@ pub unsafe fn dc_array_search_id(
     needle: uint32_t,
     ret_index: *mut size_t,
 ) -> bool {
-    if array.is_null() {
-        return false;
-    }
+    assert!(!array.is_null());
+
     if let Some(i) = (*array).search_id(needle as uintptr_t) {
         if !ret_index.is_null() {
             *ret_index = i
@@ -321,9 +285,8 @@ pub unsafe fn dc_array_search_id(
 }
 
 pub unsafe fn dc_array_get_raw(array: *const dc_array_t) -> *const uintptr_t {
-    if array.is_null() {
-        return 0 as *const uintptr_t;
-    }
+    assert!(!array.is_null());
+
     if let dc_array_t::Uint(v) = &*array {
         v.as_ptr()
     } else {
@@ -340,27 +303,24 @@ pub fn dc_array_new_locations(initsize: size_t) -> *mut dc_array_t {
 }
 
 pub unsafe fn dc_array_empty(array: *mut dc_array_t) {
-    if array.is_null() {
-        return;
-    }
+    assert!(!array.is_null());
+
     (*array).clear()
 }
 
 pub unsafe fn dc_array_duplicate(array: *const dc_array_t) -> *mut dc_array_t {
-    if array.is_null() {
-        std::ptr::null_mut()
-    } else {
-        (*array).clone().into_raw()
-    }
+    assert!(!array.is_null());
+
+    (*array).clone().into_raw()
 }
 
 pub unsafe fn dc_array_get_string(
     array: *const dc_array_t,
     sep: *const libc::c_char,
 ) -> *mut libc::c_char {
-    if array.is_null() || sep.is_null() {
-        return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
-    }
+    assert!(!array.is_null());
+    assert!(!sep.is_null());
+
     if let dc_array_t::Uint(v) = &*array {
         let cnt = v.len();
         let sep = as_str(sep);
@@ -406,10 +366,6 @@ mod tests {
                 );
             }
 
-            assert_eq!(dc_array_get_id(arr, -1i32 as size_t), 0);
-            assert_eq!(dc_array_get_id(arr, 1000 as size_t), 0);
-            assert_eq!(dc_array_get_id(arr, 1001 as size_t), 0);
-
             dc_array_empty(arr);
 
             assert_eq!(dc_array_get_cnt(arr), 0);
@@ -438,4 +394,14 @@ mod tests {
         }
     }
 
+    #[test]
+    #[should_panic]
+    fn test_dc_array_out_of_bounds() {
+        let arr = dc_array_new(7);
+        for i in 0..1000 {
+            unsafe { dc_array_add_id(arr, (i + 2) as uint32_t) };
+        }
+        unsafe { dc_array_get_id(arr, 1000) };
+    }
+
 }

src/dc_chat.rs

@@ -2,9 +2,9 @@ use std::ffi::CString;
 
 use crate::chatlist::*;
 use crate::constants::*;
+use crate::contact::*;
 use crate::context::Context;
 use crate::dc_array::*;
-use crate::dc_contact::*;
 use crate::dc_job::*;
 use crate::dc_msg::*;
 use crate::dc_tools::*;
@@ -24,7 +24,6 @@ use crate::x::*;
  */
 #[derive(Clone)]
 pub struct Chat<'a> {
-    magic: uint32_t,
     pub id: uint32_t,
     pub type_0: libc::c_int,
     pub name: *mut libc::c_char,
@@ -52,7 +51,7 @@ pub unsafe fn dc_create_chat_by_msg_id(context: &Context, msg_id: uint32_t) -> u
             dc_unblock_chat(context, (*chat).id);
             send_event = 1i32
         }
-        dc_scaleup_contact_origin(context, (*msg).from_id, 0x800i32);
+        Contact::scaleup_origin_by_id(context, (*msg).from_id, Origin::CreateChat);
     }
 
     dc_msg_unref(msg);
@@ -65,7 +64,6 @@ pub unsafe fn dc_create_chat_by_msg_id(context: &Context, msg_id: uint32_t) -> u
 
 pub unsafe fn dc_chat_new<'a>(context: &'a Context) -> *mut Chat<'a> {
     let chat = Chat {
-        magic: 0xc4a7c4a7,
         id: 0,
         type_0: 0,
         name: std::ptr::null_mut(),
@@ -81,17 +79,16 @@ pub unsafe fn dc_chat_new<'a>(context: &'a Context) -> *mut Chat<'a> {
     Box::into_raw(Box::new(chat))
 }
 
-pub unsafe fn dc_chat_unref(mut chat: *mut Chat) {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+pub unsafe fn dc_chat_unref(chat: *mut Chat) {
+    if chat.is_null() {
         return;
     }
     dc_chat_empty(chat);
-    (*chat).magic = 0;
     Box::from_raw(chat);
 }
 
 pub unsafe fn dc_chat_empty(mut chat: *mut Chat) {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return;
     }
     free((*chat).name as *mut libc::c_void);
@@ -120,7 +117,7 @@ pub fn dc_block_chat(context: &Context, chat_id: u32, new_blocking: libc::c_int)
 }
 
 pub fn dc_chat_load_from_db(chat: *mut Chat, chat_id: u32) -> bool {
-    if chat.is_null() || unsafe { (*chat).magic != 0xc4a7c4a7u32 } {
+    if chat.is_null() {
         return false;
     }
     unsafe { dc_chat_empty(chat) };
@@ -206,7 +203,9 @@ pub unsafe fn dc_create_chat_by_contact_id(context: &Context, contact_id: uint32
             dc_unblock_chat(context, chat_id);
             send_event = 1i32
         }
-    } else if !dc_real_contact_exists(context, contact_id) && contact_id != 1i32 as libc::c_uint {
+    } else if !Contact::real_exists_by_id(context, contact_id)
+        && contact_id != DC_CONTACT_ID_SELF as u32
+    {
         warn!(
             context,
             0, "Cannot create chat, contact {} does not exist.", contact_id as libc::c_int,
@@ -222,7 +221,7 @@ pub unsafe fn dc_create_chat_by_contact_id(context: &Context, contact_id: uint32
         if 0 != chat_id {
             send_event = 1;
         }
-        dc_scaleup_contact_origin(context, contact_id, 0x800i32);
+        Contact::scaleup_origin_by_id(context, contact_id, Origin::CreateChat);
     }
     if 0 != send_event {
         context.call_cb(Event::MSGS_CHANGED, 0i32 as uintptr_t, 0i32 as uintptr_t);
@@ -239,8 +238,6 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
 ) {
     let mut chat_id = 0;
     let mut chat_blocked = 0;
-    let contact: *mut dc_contact_t;
-    let chat_name: *mut libc::c_char;
 
     if !ret_chat_id.is_null() {
         *ret_chat_id = 0;
@@ -264,14 +261,8 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
         }
         return;
     }
-    contact = dc_contact_new(context);
-    if dc_contact_load_from_db(contact, &context.sql, contact_id) {
-        chat_name =
-            if !(*contact).name.is_null() && 0 != *(*contact).name.offset(0isize) as libc::c_int {
-                (*contact).name
-            } else {
-                (*contact).addr
-            };
+    if let Ok(contact) = Contact::load_from_db(context, contact_id) {
+        let chat_name = contact.get_display_name();
 
         if sql::execute(
             context,
@@ -279,10 +270,10 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
             format!(
                 "INSERT INTO chats (type, name, param, blocked, grpid) VALUES({}, '{}', '{}', {}, '{}')",
                 100,
-                as_str(chat_name),
-                if contact_id == 1 { "K=1" } else { "" },
+                chat_name,
+                if contact_id == DC_CONTACT_ID_SELF as u32 { "K=1" } else { "" },
                 create_blocked,
-                as_str((*contact).addr),
+                contact.get_addr(),
             ),
             params![],
         ).is_ok() {
@@ -291,7 +282,7 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
                 &context.sql,
                 "chats",
                 "grpid",
-                as_str((*contact).addr),
+                contact.get_addr(),
             );
 
             sql::execute(
@@ -303,7 +294,6 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
         }
     }
 
-    dc_contact_unref(contact);
     if !ret_chat_id.is_null() {
         *ret_chat_id = chat_id
     }
@@ -725,7 +715,7 @@ unsafe fn prepare_msg_raw(
                             timestamp,
                             (*msg).type_0,
                             (*msg).state,
-                            if !(*msg).text.is_null() { Some(as_str((*msg).text)) } else { None },
+                            (*msg).text,
                             (*msg).param.to_string(),
                             (*msg).hidden,
                             to_string(new_in_reply_to),
@@ -817,7 +807,7 @@ unsafe fn get_parent_mime_headers(
 }
 
 pub unsafe fn dc_chat_is_self_talk(chat: *const Chat) -> libc::c_int {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return 0;
     }
     (*chat).param.exists(Param::Selftalk) as libc::c_int
@@ -951,7 +941,7 @@ pub unsafe fn dc_send_msg<'a>(
 pub unsafe fn dc_send_text_msg(
     context: &Context,
     chat_id: uint32_t,
-    text_to_send: *const libc::c_char,
+    text_to_send: String,
 ) -> uint32_t {
     if chat_id <= 9 {
         warn!(
@@ -961,18 +951,8 @@ pub unsafe fn dc_send_text_msg(
         return 0;
     }
 
-    if text_to_send.is_null() {
-        warn!(context, 0, "dc_send_text_msg: text_to_send is emtpy");
-        return 0;
-    }
-
-    if let Err(err) = as_str_safe(text_to_send) {
-        warn!(context, 0, "{}", err);
-        return 0;
-    }
-
     let mut msg = dc_msg_new(context, Viewtype::Text);
-    (*msg).text = dc_strdup(text_to_send);
+    (*msg).text = Some(text_to_send);
     let ret = dc_send_msg(context, chat_id, msg);
     dc_msg_unref(msg);
     ret
@@ -1002,9 +982,7 @@ unsafe fn set_draft_raw(context: &Context, chat_id: uint32_t, msg: *mut dc_msg_t
     // save new draft
     if !msg.is_null() {
         if (*msg).type_0 == Viewtype::Text {
-            if (*msg).text.is_null() || *(*msg).text.offset(0isize) as libc::c_int == 0i32 {
-                OK_TO_CONTINUE = false;
-            }
+            OK_TO_CONTINUE = (*msg).text.as_ref().map_or(false, |s| !s.is_empty());
         } else if msgtype_has_file((*msg).type_0) {
             let mut pathNfilename = (*msg)
                 .param
@@ -1037,11 +1015,7 @@ unsafe fn set_draft_raw(context: &Context, chat_id: uint32_t, msg: *mut dc_msg_t
                     time(),
                     (*msg).type_0,
                     DC_STATE_OUT_DRAFT,
-                    if !(*msg).text.is_null() {
-                        as_str((*msg).text)
-                    } else {
-                        ""
-                    },
+                    (*msg).text.as_ref().map(String::as_str).unwrap_or(""),
                     (*msg).param.to_string(),
                     1,
                 ],
@@ -1095,7 +1069,7 @@ pub fn dc_get_chat_msgs(
     flags: uint32_t,
     marker1before: uint32_t,
 ) -> *mut dc_array_t {
-    let mut ret = dc_array_t::new(512);
+    let mut ret = Vec::new();
 
     let mut last_day = 0;
     let cnv_to_local = dc_gm2local_offset();
@@ -1105,17 +1079,17 @@ pub fn dc_get_chat_msgs(
         for row in rows {
             let (curr_id, ts) = row?;
             if curr_id as u32 == marker1before {
-                ret.add_id(1);
+                ret.push(DC_MSG_ID_MARKER1 as u32);
             }
             if 0 != flags & 0x1 {
                 let curr_local_timestamp = ts + cnv_to_local;
                 let curr_day = (curr_local_timestamp / 86400) as libc::c_int;
                 if curr_day != last_day {
-                    ret.add_id(9);
+                    ret.push(DC_MSG_ID_LAST_SPECIAL as u32);
                     last_day = curr_day;
                 }
             }
-            ret.add_id(curr_id as u32);
+            ret.push(curr_id as u32);
         }
         Ok(())
     };
@@ -1163,7 +1137,7 @@ pub fn dc_get_chat_msgs(
     };
 
     if success.is_ok() {
-        ret.into_raw()
+        dc_array_t::from(ret).into_raw()
     } else {
         0 as *mut dc_array_t
     }
@@ -1276,11 +1250,11 @@ pub fn dc_get_chat_media(
         ],
         |row| row.get::<_, i32>(0),
         |ids| {
-            let mut ret = dc_array_t::new(100);
+            let mut ret = Vec::new();
             for id in ids {
-                ret.add_id(id? as u32);
+                ret.push(id? as u32);
             }
-            Ok(ret.into_raw())
+            Ok(dc_array_t::from(ret).into_raw())
         }
     ).unwrap_or_else(|_| std::ptr::null_mut())
 }
@@ -1333,7 +1307,9 @@ pub unsafe fn dc_get_next_media(
         }
     }
 
-    dc_array_unref(list);
+    if !list.is_null() {
+        dc_array_unref(list);
+    }
     dc_msg_unref(msg);
     ret_msg_id
 }
@@ -1429,12 +1405,12 @@ pub fn dc_delete_chat(context: &Context, chat_id: u32) -> bool {
     true
 }
 
-pub fn dc_get_chat_contacts(context: &Context, chat_id: u32) -> *mut dc_array_t {
+pub fn dc_get_chat_contacts(context: &Context, chat_id: u32) -> Vec<u32> {
     /* Normal chats do not include SELF.  Group chats do (as it may happen that one is deleted from a
     groupchat but the chats stays visible, moreover, this makes displaying lists easier) */
 
     if chat_id == 1 {
-        return std::ptr::null_mut();
+        return Vec::new();
     }
 
     // we could also create a list for all contacts in the deaddrop by searching contacts belonging to chats with
@@ -1446,19 +1422,11 @@ pub fn dc_get_chat_contacts(context: &Context, chat_id: u32) -> *mut dc_array_t
             "SELECT cc.contact_id FROM chats_contacts cc \
              LEFT JOIN contacts c ON c.id=cc.contact_id WHERE cc.chat_id=? \
              ORDER BY c.id=1, LOWER(c.name||c.addr), c.id;",
-            params![chat_id as i32],
-            |row| row.get::<_, i32>(0),
-            |ids| {
-                let mut ret = dc_array_t::new(100);
-
-                for id in ids {
-                    ret.add_id(id? as u32);
-                }
-
-                Ok(ret.into_raw())
-            },
+            params![chat_id],
+            |row| row.get::<_, u32>(0),
+            |ids| ids.collect::<Result<Vec<_>, _>>().map_err(Into::into),
         )
-        .unwrap_or_else(|_| std::ptr::null_mut())
+        .unwrap_or_default()
 }
 
 pub unsafe fn dc_get_chat(context: &Context, chat_id: uint32_t) -> *mut Chat {
@@ -1558,15 +1526,18 @@ pub unsafe fn dc_add_contact_to_chat_ex(
 ) -> libc::c_int {
     let mut OK_TO_CONTINUE = true;
     let mut success: libc::c_int = 0;
-    let contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
+    let contact = Contact::get_by_id(context, contact_id);
     let chat: *mut Chat = dc_chat_new(context);
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
 
-    if !(contact.is_null() || chat_id <= 9 as libc::c_uint) {
+    if !(contact.is_err() || chat_id <= 9 as libc::c_uint) {
         dc_reset_gossiped_timestamp(context, chat_id);
+        let contact = contact.unwrap();
+
         /*this also makes sure, not contacts are added to special or normal chats*/
         if !(0 == real_group_exists(context, chat_id)
-            || !dc_real_contact_exists(context, contact_id) && contact_id != 1 as libc::c_uint
+            || !Contact::real_exists_by_id(context, contact_id)
+                && contact_id != DC_CONTACT_ID_SELF as u32
             || !dc_chat_load_from_db(chat, chat_id))
         {
             if !(dc_is_contact_in_chat(context, chat_id, 1 as uint32_t) == 1) {
@@ -1588,7 +1559,7 @@ pub unsafe fn dc_add_contact_to_chat_ex(
                     .sql
                     .get_config(context, "configured_addr")
                     .unwrap_or_default();
-                if as_str((*contact).addr) != &self_addr {
+                if contact.get_addr() != &self_addr {
                     // ourself is added using DC_CONTACT_ID_SELF, do not add it explicitly.
                     // if SELF is not in the group, members cannot be added at all.
 
@@ -1600,7 +1571,7 @@ pub unsafe fn dc_add_contact_to_chat_ex(
                     } else {
                         // else continue and send status mail
                         if (*chat).type_0 == 130 {
-                            if dc_contact_is_verified(contact) != 2 {
+                            if contact.is_verified() != VerifiedStatus::BidirectVerified {
                                 error!(
                                     context, 0,
                                     "Only bidirectional verified contacts can be added to verified groups."
@@ -1617,18 +1588,14 @@ pub unsafe fn dc_add_contact_to_chat_ex(
                     if OK_TO_CONTINUE {
                         if (*chat).param.get_int(Param::Unpromoted).unwrap_or_default() == 0 {
                             (*msg).type_0 = Viewtype::Text;
-                            (*msg).text = context
-                                .stock_system_msg(
-                                    StockMessage::MsgAddMember,
-                                    as_str((*contact).addr),
-                                    "",
-                                    DC_CONTACT_ID_SELF as uint32_t,
-                                )
-                                .strdup();
+                            (*msg).text = Some(context.stock_system_msg(
+                                StockMessage::MsgAddMember,
+                                contact.get_addr(),
+                                "",
+                                DC_CONTACT_ID_SELF as uint32_t,
+                            ));
                             (*msg).param.set_int(Param::Cmd, 4);
-                            if !(*contact).addr.is_null() {
-                                (*msg).param.set(Param::Arg, as_str((*contact).addr));
-                            }
+                            (*msg).param.set(Param::Arg, contact.get_addr());
                             (*msg).param.set_int(Param::Arg2, flags);
                             (*msg).id = dc_send_msg(context, chat_id, msg);
                             context.call_cb(
@@ -1645,7 +1612,6 @@ pub unsafe fn dc_add_contact_to_chat_ex(
         }
     }
     dc_chat_unref(chat);
-    dc_contact_unref(contact);
     dc_msg_unref(msg);
 
     success
@@ -1707,13 +1673,12 @@ pub unsafe fn dc_remove_contact_from_chat(
     chat_id: u32,
     contact_id: u32,
 ) -> libc::c_int {
-    let mut success: libc::c_int = 0;
-    let contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
+    let mut success = 0;
     let chat: *mut Chat = dc_chat_new(context);
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
 
     if !(chat_id <= 9 as libc::c_uint
-        || contact_id <= 9 as libc::c_uint && contact_id != 1 as libc::c_uint)
+        || contact_id <= 9 as libc::c_uint && contact_id != DC_CONTACT_ID_SELF as u32)
     {
         /* we do not check if "contact_id" exists but just delete all records with the id from chats_contacts */
         /* this allows to delete pending references to deleted contacts.  Of course, this should _not_ happen. */
@@ -1727,33 +1692,27 @@ pub unsafe fn dc_remove_contact_from_chat(
                 );
             } else {
                 /* we should respect this - whatever we send to the group, it gets discarded anyway! */
-                if !contact.is_null() {
+                if let Ok(contact) = Contact::get_by_id(context, contact_id) {
                     if (*chat).param.get_int(Param::Unpromoted).unwrap_or_default() == 0 {
                         (*msg).type_0 = Viewtype::Text;
-                        if (*contact).id == 1 as libc::c_uint {
+                        if contact.id == DC_CONTACT_ID_SELF as u32 {
                             dc_set_group_explicitly_left(context, (*chat).grpid);
-                            (*msg).text = context
-                                .stock_system_msg(
-                                    StockMessage::MsgGroupLeft,
-                                    "",
-                                    "",
-                                    DC_CONTACT_ID_SELF as u32,
-                                )
-                                .strdup();
+                            (*msg).text = Some(context.stock_system_msg(
+                                StockMessage::MsgGroupLeft,
+                                "",
+                                "",
+                                DC_CONTACT_ID_SELF as u32,
+                            ));
                         } else {
-                            (*msg).text = context
-                                .stock_system_msg(
-                                    StockMessage::MsgDelMember,
-                                    as_str((*contact).addr),
-                                    "",
-                                    DC_CONTACT_ID_SELF as u32,
-                                )
-                                .strdup();
+                            (*msg).text = Some(context.stock_system_msg(
+                                StockMessage::MsgDelMember,
+                                contact.get_addr(),
+                                "",
+                                DC_CONTACT_ID_SELF as u32,
+                            ));
                         }
                         (*msg).param.set_int(Param::Cmd, 5);
-                        if !(*contact).addr.is_null() {
-                            (*msg).param.set(Param::Arg, as_str((*contact).addr));
-                        }
+                        (*msg).param.set(Param::Arg, contact.get_addr());
                         (*msg).id = dc_send_msg(context, chat_id, msg);
                         context.call_cb(
                             Event::MSGS_CHANGED,
@@ -1778,7 +1737,6 @@ pub unsafe fn dc_remove_contact_from_chat(
     }
 
     dc_chat_unref(chat);
-    dc_contact_unref(contact);
     dc_msg_unref(msg);
 
     success
@@ -1849,14 +1807,12 @@ pub unsafe fn dc_set_chat_name(
                 {
                     if (*chat).param.get_int(Param::Unpromoted).unwrap_or_default() == 0 {
                         (*msg).type_0 = Viewtype::Text;
-                        (*msg).text = context
-                            .stock_system_msg(
-                                StockMessage::MsgGrpName,
-                                as_str((*chat).name),
-                                as_str(new_name),
-                                DC_CONTACT_ID_SELF as u32,
-                            )
-                            .strdup();
+                        (*msg).text = Some(context.stock_system_msg(
+                            StockMessage::MsgGrpName,
+                            as_str((*chat).name),
+                            as_str(new_name),
+                            DC_CONTACT_ID_SELF as u32,
+                        ));
                         (*msg).param.set_int(Param::Cmd, 2);
                         if !(*chat).name.is_null() {
                             (*msg).param.set(Param::Arg, as_str((*chat).name));
@@ -1923,18 +1879,16 @@ pub unsafe fn dc_set_chat_profile_image(
                             (*msg).param.set_int(Param::Cmd, 3);
                             (*msg).param.set(Param::Arg, as_str(new_image_rel));
                             (*msg).type_0 = Viewtype::Text;
-                            (*msg).text = context
-                                .stock_system_msg(
-                                    if !new_image_rel.is_null() {
-                                        StockMessage::MsgGrpImgChanged
-                                    } else {
-                                        StockMessage::MsgGrpImgDeleted
-                                    },
-                                    "",
-                                    "",
-                                    DC_CONTACT_ID_SELF as uint32_t,
-                                )
-                                .strdup();
+                            (*msg).text = Some(context.stock_system_msg(
+                                if !new_image_rel.is_null() {
+                                    StockMessage::MsgGrpImgChanged
+                                } else {
+                                    StockMessage::MsgGrpImgDeleted
+                                },
+                                "",
+                                "",
+                                DC_CONTACT_ID_SELF as uint32_t,
+                            ));
                             (*msg).id = dc_send_msg(context, chat_id, msg);
                             context.call_cb(
                                 Event::MSGS_CHANGED,
@@ -1973,7 +1927,6 @@ pub unsafe fn dc_forward_msgs(
 
     let msg = dc_msg_new_untyped(context);
     let chat = dc_chat_new(context);
-    let contact = dc_contact_new(context);
     let mut created_db_entries = Vec::new();
     let mut curr_timestamp: i64;
 
@@ -2007,7 +1960,7 @@ pub unsafe fn dc_forward_msgs(
                 break;
             }
             let original_param = (*msg).param.clone();
-            if (*msg).from_id != 1 {
+            if (*msg).from_id != DC_CONTACT_ID_SELF as u32 {
                 (*msg).param.set_int(Param::Forwarded, 1);
             }
             (*msg).param.remove(Param::GuranteeE2ee);
@@ -2053,27 +2006,26 @@ pub unsafe fn dc_forward_msgs(
             created_db_entries[i + 1] as uintptr_t,
         );
     }
-    dc_contact_unref(contact);
     dc_msg_unref(msg);
     dc_chat_unref(chat);
 }
 
 pub unsafe fn dc_chat_get_id(chat: *const Chat) -> uint32_t {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return 0i32 as uint32_t;
     }
     (*chat).id
 }
 
 pub unsafe fn dc_chat_get_type(chat: *const Chat) -> libc::c_int {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return 0i32;
     }
     (*chat).type_0
 }
 
 pub unsafe fn dc_chat_get_name(chat: *const Chat) -> *mut libc::c_char {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return dc_strdup(b"Err\x00" as *const u8 as *const libc::c_char);
     }
     dc_strdup((*chat).name)
@@ -2081,7 +2033,7 @@ pub unsafe fn dc_chat_get_name(chat: *const Chat) -> *mut libc::c_char {
 
 pub unsafe fn dc_chat_get_subtitle(chat: *const Chat) -> *mut libc::c_char {
     /* returns either the address or the number of chat members */
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return dc_strdup(b"Err\x00" as *const u8 as *const libc::c_char);
     }
 
@@ -2138,9 +2090,8 @@ pub fn dc_get_chat_contact_cnt(context: &Context, chat_id: u32) -> libc::c_int {
 pub unsafe fn dc_chat_get_profile_image(chat: *const Chat) -> *mut libc::c_char {
     let mut image_rel: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut image_abs: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut contacts: *mut dc_array_t = 0 as *mut dc_array_t;
-    let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
-    if !(chat.is_null() || (*chat).magic != 0xc4a7c4a7u32) {
+
+    if !chat.is_null() {
         image_rel = (*chat)
             .param
             .get(Param::ProfileImage)
@@ -2148,47 +2099,45 @@ pub unsafe fn dc_chat_get_profile_image(chat: *const Chat) -> *mut libc::c_char
             .strdup();
         if !image_rel.is_null() && 0 != *image_rel.offset(0isize) as libc::c_int {
             image_abs = dc_get_abs_path((*chat).context, image_rel)
-        } else if (*chat).type_0 == 100i32 {
-            contacts = dc_get_chat_contacts((*chat).context, (*chat).id);
-            if !(*contacts).is_empty() {
-                contact = dc_get_contact((*chat).context, (*contacts).get_id(0));
-                image_abs = dc_contact_get_profile_image(contact)
+        } else if (*chat).type_0 == DC_CHAT_TYPE_SINGLE {
+            let contacts = dc_get_chat_contacts((*chat).context, (*chat).id);
+            if !contacts.is_empty() {
+                if let Ok(contact) = Contact::get_by_id((*chat).context, contacts[0]) {
+                    if let Some(img) = contact.get_profile_image() {
+                        image_abs = img.strdup();
+                    }
+                }
             }
         }
     }
 
     free(image_rel as *mut libc::c_void);
-    dc_array_unref(contacts);
-    dc_contact_unref(contact);
 
     image_abs
 }
 
 pub unsafe fn dc_chat_get_color(chat: *const Chat) -> uint32_t {
     let mut color: uint32_t = 0i32 as uint32_t;
-    let mut contacts: *mut dc_array_t = 0 as *mut dc_array_t;
-    let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
-    if !(chat.is_null() || (*chat).magic != 0xc4a7c4a7u32) {
-        if (*chat).type_0 == 100i32 {
-            contacts = dc_get_chat_contacts((*chat).context, (*chat).id);
-            if !(*contacts).is_empty() {
-                contact = dc_get_contact((*chat).context, (*contacts).get_id(0));
-                color = dc_str_to_color((*contact).addr) as uint32_t
+
+    if !chat.is_null() {
+        if (*chat).type_0 == DC_CHAT_TYPE_SINGLE {
+            let contacts = dc_get_chat_contacts((*chat).context, (*chat).id);
+            if !contacts.is_empty() {
+                if let Ok(contact) = Contact::get_by_id((*chat).context, contacts[0]) {
+                    color = contact.get_color();
+                }
             }
         } else {
             color = dc_str_to_color((*chat).name) as uint32_t
         }
     }
 
-    dc_array_unref(contacts);
-    dc_contact_unref(contact);
-
     color
 }
 
 // TODO should return bool /rtn
 pub unsafe fn dc_chat_get_archived(chat: *const Chat) -> libc::c_int {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return 0i32;
     }
     (*chat).archived
@@ -2196,7 +2145,7 @@ pub unsafe fn dc_chat_get_archived(chat: *const Chat) -> libc::c_int {
 
 // TODO should return bool /rtn
 pub unsafe fn dc_chat_is_unpromoted(chat: *const Chat) -> libc::c_int {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return 0;
     }
     (*chat).param.get_int(Param::Unpromoted).unwrap_or_default() as libc::c_int
@@ -2204,7 +2153,7 @@ pub unsafe fn dc_chat_is_unpromoted(chat: *const Chat) -> libc::c_int {
 
 // TODO should return bool /rtn
 pub unsafe fn dc_chat_is_verified(chat: *const Chat) -> libc::c_int {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return 0i32;
     }
     ((*chat).type_0 == 130i32) as libc::c_int
@@ -2212,7 +2161,7 @@ pub unsafe fn dc_chat_is_verified(chat: *const Chat) -> libc::c_int {
 
 // TODO should return bool /rtn
 pub unsafe fn dc_chat_is_sending_locations(chat: *const Chat) -> libc::c_int {
-    if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
+    if chat.is_null() {
         return 0i32;
     }
     (*chat).is_sending_locations

src/dc_dehtml.rs

@@ -11,7 +11,7 @@ lazy_static! {
 struct Dehtml {
     strbuilder: String,
     add_text: AddText,
-    last_href: *mut libc::c_char,
+    last_href: Option<String>,
 }
 
 #[derive(Debug, PartialEq)]
@@ -32,7 +32,7 @@ pub unsafe fn dc_dehtml(buf_terminated: *mut libc::c_char) -> *mut libc::c_char
     let mut dehtml = Dehtml {
         strbuilder: String::with_capacity(strlen(buf_terminated)),
         add_text: AddText::YesRemoveLineEnds,
-        last_href: 0 as *mut libc::c_char,
+        last_href: None,
     };
     let mut saxparser = dc_saxparser_t {
         starttag_cb: None,
@@ -51,7 +51,6 @@ pub unsafe fn dc_dehtml(buf_terminated: *mut libc::c_char) -> *mut libc::c_char
     );
     dc_saxparser_set_text_handler(&mut saxparser, Some(dehtml_text_cb));
     dc_saxparser_parse(&mut saxparser, buf_terminated);
-    free(dehtml.last_href as *mut libc::c_void);
 
     dehtml.strbuilder.strdup()
 }
@@ -66,7 +65,11 @@ unsafe fn dehtml_text_cb(
     if dehtml.add_text == AddText::YesPreserveLineEnds
         || dehtml.add_text == AddText::YesRemoveLineEnds
     {
-        let last_added = std::ffi::CStr::from_ptr(text).to_string_lossy();
+        let last_added = std::ffi::CStr::from_ptr(text)
+            .to_str()
+            .expect("invalid utf8");
+        // TODO: why does len does not match?
+        // assert_eq!(last_added.len(), len as usize);
 
         if dehtml.add_text == AddText::YesRemoveLineEnds {
             dehtml.strbuilder += LINE_RE.replace_all(last_added.as_ref(), "\r").as_ref();
@@ -86,14 +89,10 @@ unsafe fn dehtml_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char
             dehtml.add_text = AddText::YesRemoveLineEnds;
         }
         "a" => {
-            if !dehtml.last_href.is_null() {
+            if let Some(ref last_href) = dehtml.last_href.take() {
                 dehtml.strbuilder += "](";
-                dehtml.strbuilder += std::ffi::CStr::from_ptr((*dehtml).last_href)
-                    .to_string_lossy()
-                    .as_ref();
+                dehtml.strbuilder += last_href;
                 dehtml.strbuilder += ")";
-                free(dehtml.last_href as *mut libc::c_void);
-                dehtml.last_href = 0 as *mut libc::c_char;
             }
         }
         "b" | "strong" => {
@@ -131,12 +130,13 @@ unsafe fn dehtml_starttag_cb(
             dehtml.add_text = AddText::YesPreserveLineEnds;
         }
         "a" => {
-            free(dehtml.last_href as *mut libc::c_void);
-            dehtml.last_href = dc_strdup_keep_null(dc_attr_find(
+            let text_c = std::ffi::CStr::from_ptr(dc_attr_find(
                 attr,
                 b"href\x00" as *const u8 as *const libc::c_char,
             ));
-            if !dehtml.last_href.is_null() {
+            let text_r = text_c.to_str().expect("invalid utf8");
+            if !text_r.is_empty() {
+                dehtml.last_href = Some(text_r.to_string());
                 dehtml.strbuilder += "[";
             }
         }

src/dc_e2ee.rs

@@ -1,3 +1,5 @@
+//! End-to-end encryption support.
+
 use std::collections::HashSet;
 use std::ffi::CStr;
 use std::str::FromStr;
@@ -16,10 +18,12 @@ use mmime::mmapstring::*;
 use mmime::{mailmime_substitute, MAILIMF_NO_ERROR, MAIL_NO_ERROR};
 
 use crate::aheader::*;
+use crate::config::Config;
 use crate::context::Context;
 use crate::dc_mimeparser::*;
 use crate::dc_securejoin::*;
 use crate::dc_tools::*;
+use crate::error::*;
 use crate::key::*;
 use crate::keyring::*;
 use crate::peerstate::*;
@@ -66,7 +70,7 @@ pub unsafe fn dc_e2ee_encrypt(
     mut in_out_message: *mut mailmime,
     helper: &mut dc_e2ee_helper_t,
 ) {
-    let mut current_block: u64 = 0;
+    let mut ok_to_continue = true;
     let mut col: libc::c_int = 0i32;
     let mut do_encrypt: libc::c_int = 0i32;
     /*just a pointer into mailmime structure, must not be freed*/
@@ -96,9 +100,11 @@ pub unsafe fn dc_e2ee_encrypt(
         let addr = context.sql.get_config(context, "configured_addr");
 
         if let Some(addr) = addr {
-            if let Some(public_key) =
-                load_or_generate_self_public_key(context, &addr, in_out_message)
-            {
+            let pubkey_ret = load_or_generate_self_public_key(context, &addr).map_err(|err| {
+                error!(context, 0, "Failed to load public key: {}", err);
+                err
+            });
+            if let Ok(public_key) = pubkey_ret {
                 /*only for random-seed*/
                 if prefer_encrypt == EncryptPreference::Mutual || 0 != e2ee_guaranteed {
                     do_encrypt = 1i32;
@@ -115,11 +121,22 @@ pub unsafe fn dc_e2ee_encrypt(
                                     || 0 != e2ee_guaranteed)
                             {
                                 let peerstate = peerstate.unwrap();
+                                info!(
+                                    context,
+                                    0, "dc_e2ee_encrypt {} has peerstate", recipient_addr
+                                );
                                 if let Some(key) = peerstate.peek_key(min_verified as usize) {
                                     keyring.add_owned(key.clone());
                                     peerstates.push(peerstate);
                                 }
                             } else {
+                                info!(
+                                    context,
+                                    0,
+                                    "dc_e2ee_encrypt {} HAS NO peerstate {}",
+                                    recipient_addr,
+                                    peerstate.is_some()
+                                );
                                 do_encrypt = 0i32;
                                 /* if we cannot encrypt to a single recipient, we cannot encrypt the message at all */
                                 break;
@@ -283,7 +300,7 @@ pub unsafe fn dc_e2ee_encrypt(
                         );
                         mailmime_write_mem(plain, &mut col, message_to_encrypt);
                         if (*plain).str_0.is_null() || (*plain).len <= 0 {
-                            current_block = 14181132614457621749;
+                            ok_to_continue = false;
                         } else {
                             if let Some(ctext_v) = dc_pgp_pk_encrypt(
                                 (*plain).str_0 as *const libc::c_void,
@@ -293,7 +310,7 @@ pub unsafe fn dc_e2ee_encrypt(
                             ) {
                                 let ctext_bytes = ctext_v.len();
                                 let ctext = ctext_v.strdup();
-                                (*helper).cdata_to_free = ctext as *mut _;
+                                helper.cdata_to_free = ctext as *mut _;
 
                                 /* create MIME-structure that will contain the encrypted text */
                                 let mut encrypted_part: *mut mailmime = new_data_part(
@@ -339,25 +356,19 @@ pub unsafe fn dc_e2ee_encrypt(
                                 (*in_out_message).mm_data.mm_message.mm_msg_mime = encrypted_part;
                                 (*encrypted_part).mm_parent = in_out_message;
                                 mailmime_free(message_to_encrypt);
-                                (*helper).encryption_successfull = 1i32;
-                                current_block = 13824533195664196414;
+                                helper.encryption_successfull = 1i32;
                             }
                         }
-                    } else {
-                        current_block = 13824533195664196414;
                     }
-                    match current_block {
-                        14181132614457621749 => {}
-                        _ => {
-                            let aheader = Aheader::new(addr, public_key, prefer_encrypt);
-                            mailimf_fields_add(
-                                imffields_unprotected,
-                                mailimf_field_new_custom(
-                                    "Autocrypt".strdup(),
-                                    aheader.to_string().strdup(),
-                                ),
-                            );
-                        }
+                    if ok_to_continue {
+                        let aheader = Aheader::new(addr, public_key, prefer_encrypt);
+                        mailimf_fields_add(
+                            imffields_unprotected,
+                            mailimf_field_new_custom(
+                                "Autocrypt".strdup(),
+                                aheader.to_string().strdup(),
+                            ),
+                        );
                     }
                 }
             }
@@ -378,7 +389,7 @@ unsafe fn new_data_part(
     default_content_type: *mut libc::c_char,
     default_encoding: libc::c_int,
 ) -> *mut mailmime {
-    let mut current_block: u64;
+    let mut ok_to_continue = true;
     //char basename_buf[PATH_MAX];
     let mut encoding: *mut mailmime_mechanism;
     let content: *mut mailmime_content;
@@ -398,7 +409,7 @@ unsafe fn new_data_part(
     }
     content = mailmime_content_new_with_str(content_type_str);
     if content.is_null() {
-        current_block = 16266721588079097885;
+        ok_to_continue = false;
     } else {
         do_encoding = 1i32;
         if (*(*content).ct_type).tp_type == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int {
@@ -426,117 +437,94 @@ unsafe fn new_data_part(
             }
             encoding = mailmime_mechanism_new(encoding_type, 0 as *mut libc::c_char);
             if encoding.is_null() {
-                current_block = 16266721588079097885;
-            } else {
-                current_block = 11057878835866523405;
+                ok_to_continue = false;
             }
-        } else {
-            current_block = 11057878835866523405;
         }
-        match current_block {
-            16266721588079097885 => {}
-            _ => {
-                mime_fields = mailmime_fields_new_with_data(
-                    encoding,
-                    0 as *mut libc::c_char,
-                    0 as *mut libc::c_char,
-                    0 as *mut mailmime_disposition,
-                    0 as *mut mailmime_language,
-                );
-                if mime_fields.is_null() {
-                    current_block = 16266721588079097885;
+        if ok_to_continue {
+            mime_fields = mailmime_fields_new_with_data(
+                encoding,
+                0 as *mut libc::c_char,
+                0 as *mut libc::c_char,
+                0 as *mut mailmime_disposition,
+                0 as *mut mailmime_language,
+            );
+            if mime_fields.is_null() {
+                ok_to_continue = false;
+            } else {
+                mime = mailmime_new_empty(content, mime_fields);
+                if mime.is_null() {
+                    mailmime_fields_free(mime_fields);
+                    mailmime_content_free(content);
                 } else {
-                    mime = mailmime_new_empty(content, mime_fields);
-                    if mime.is_null() {
-                        mailmime_fields_free(mime_fields);
-                        mailmime_content_free(content);
-                    } else {
-                        if !data.is_null()
-                            && data_bytes > 0
-                            && (*mime).mm_type == MAILMIME_SINGLE as libc::c_int
-                        {
-                            mailmime_set_body_text(mime, data as *mut libc::c_char, data_bytes);
-                        }
-                        return mime;
+                    if !data.is_null()
+                        && data_bytes > 0
+                        && (*mime).mm_type == MAILMIME_SINGLE as libc::c_int
+                    {
+                        mailmime_set_body_text(mime, data as *mut libc::c_char, data_bytes);
                     }
-                    current_block = 13668317689588454213;
+                    return mime;
                 }
             }
         }
     }
-    match current_block {
-        16266721588079097885 => {
-            if !encoding.is_null() {
-                mailmime_mechanism_free(encoding);
-            }
-            if !content.is_null() {
-                mailmime_content_free(content);
-            }
+
+    if ok_to_continue == false {
+        if !encoding.is_null() {
+            mailmime_mechanism_free(encoding);
+        }
+        if !content.is_null() {
+            mailmime_content_free(content);
         }
-        _ => {}
     }
     return 0 as *mut mailmime;
 }
 
-/*******************************************************************************
- * Generate Keypairs
- ******************************************************************************/
-unsafe fn load_or_generate_self_public_key(
-    context: &Context,
-    self_addr: impl AsRef<str>,
-    _random_data_mime: *mut mailmime,
-) -> Option<Key> {
-    /* avoid double creation (we unlock the database during creation) */
-    static mut S_IN_KEY_CREATION: libc::c_int = 0;
+/// Load public key from database or generate a new one.
+///
+/// This will load a public key from the database, generating and
+/// storing a new one when one doesn't exist yet.  Care is taken to
+/// only generate one key per context even when multiple threads call
+/// this function concurrently.
+fn load_or_generate_self_public_key(context: &Context, self_addr: impl AsRef<str>) -> Result<Key> {
+    if let Some(key) = Key::from_self_public(context, &self_addr, &context.sql) {
+        return Ok(key);
+    }
+    let _guard = context.generating_key_mutex.lock().unwrap();
 
-    let mut key = Key::from_self_public(context, &self_addr, &context.sql);
-    if key.is_some() {
-        return key;
+    // Check again in case the key was generated while we were waiting for the lock.
+    if let Some(key) = Key::from_self_public(context, &self_addr, &context.sql) {
+        return Ok(key);
     }
 
-    /* create the keypair - this may take a moment, however, as this is in a thread, this is no big deal */
-    if 0 != S_IN_KEY_CREATION {
-        return None;
-    }
-    let key_creation_here = 1;
-    S_IN_KEY_CREATION = 1;
-
-    let start = clock();
+    let start = std::time::Instant::now();
     info!(
         context,
         0, "Generating keypair with {} bits, e={} ...", 2048, 65537,
     );
-
-    if let Some((public_key, private_key)) = dc_pgp_create_keypair(&self_addr) {
-        if !dc_key_save_self_keypair(
-            context,
-            &public_key,
-            &private_key,
-            &self_addr,
-            1i32,
-            &context.sql,
-        ) {
-            /*set default*/
-            warn!(context, 0, "Cannot save keypair.",);
-        } else {
-            info!(
+    match dc_pgp_create_keypair(&self_addr) {
+        Some((public_key, private_key)) => {
+            match dc_key_save_self_keypair(
                 context,
-                0,
-                "Keypair generated in {:.3}s.",
-                clock().wrapping_sub(start) as libc::c_double / 1000000 as libc::c_double,
-            );
+                &public_key,
+                &private_key,
+                &self_addr,
+                1,
+                &context.sql,
+            ) {
+                true => {
+                    info!(
+                        context,
+                        0,
+                        "Keypair generated in {:.3}s.",
+                        start.elapsed().as_secs()
+                    );
+                    Ok(public_key)
+                }
+                false => Err(format_err!("Failed to save keypair")),
+            }
         }
-
-        key = Some(public_key);
-    } else {
-        warn!(context, 0, "Cannot create keypair.");
+        None => Err(format_err!("Failed to generate keypair")),
     }
-
-    if 0 != key_creation_here {
-        S_IN_KEY_CREATION = 0;
-    }
-
-    key
 }
 
 /* returns 1 if sth. was decrypted, 0 in other cases */
@@ -556,20 +544,18 @@ pub unsafe fn dc_e2ee_decrypt(
     let mut public_keyring_for_validate = Keyring::default();
     let mut gossip_headers: *mut mailimf_fields = 0 as *mut mailimf_fields;
     if !(in_out_message.is_null() || imffields.is_null()) {
-        if !imffields.is_null() {
-            let mut field: *mut mailimf_field =
-                mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
-            if !field.is_null() && !(*field).fld_data.fld_from.is_null() {
-                from = mailimf_find_first_addr((*(*field).fld_data.fld_from).frm_mb_list)
-            }
-            field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
-            if !field.is_null() && !(*field).fld_data.fld_orig_date.is_null() {
-                let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
-                if !orig_date.is_null() {
-                    message_time = dc_timestamp_from_date((*orig_date).dt_date_time);
-                    if message_time != 0 && message_time > time() {
-                        message_time = time()
-                    }
+        let mut field: *mut mailimf_field =
+            mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
+        if !field.is_null() && !(*field).fld_data.fld_from.is_null() {
+            from = mailimf_find_first_addr((*(*field).fld_data.fld_from).frm_mb_list)
+        }
+        field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
+        if !field.is_null() && !(*field).fld_data.fld_orig_date.is_null() {
+            let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
+            if !orig_date.is_null() {
+                message_time = dc_timestamp_from_date((*orig_date).dt_date_time);
+                if message_time != 0 && message_time > time() {
+                    message_time = time()
                 }
             }
         }
@@ -590,7 +576,7 @@ pub unsafe fn dc_e2ee_decrypt(
                 }
             } else if let Some(ref header) = autocryptheader {
                 let p = Peerstate::from_header(context, header, message_time);
-                p.save_to_db(&context.sql, true);
+                assert!(p.save_to_db(&context.sql, true));
                 peerstate = Some(p);
             }
         }
@@ -835,7 +821,7 @@ unsafe fn decrypt_part(
     ret_valid_signatures: &mut HashSet<String>,
     ret_decrypted_mime: *mut *mut mailmime,
 ) -> libc::c_int {
-    let current_block: u64;
+    let mut ok_to_continue = true;
     let mime_data: *mut mailmime_data;
     let mut mime_transfer_encoding: libc::c_int = MAILMIME_MECHANISM_BINARY as libc::c_int;
     /* mmap_string_unref()'d if set */
@@ -883,9 +869,7 @@ unsafe fn decrypt_part(
             decoded_data_bytes = (*mime_data).dt_data.dt_text.dt_length;
             if decoded_data.is_null() || decoded_data_bytes <= 0 {
                 /* no error - but no data */
-                current_block = 2554982661806928548;
-            } else {
-                current_block = 4488286894823169796;
+                ok_to_continue = false;
             }
         } else {
             let r: libc::c_int;
@@ -902,53 +886,49 @@ unsafe fn decrypt_part(
                 || transfer_decoding_buffer.is_null()
                 || decoded_data_bytes <= 0
             {
-                current_block = 2554982661806928548;
+                ok_to_continue = false;
             } else {
                 decoded_data = transfer_decoding_buffer;
-                current_block = 4488286894823169796;
             }
         }
-        match current_block {
-            2554982661806928548 => {}
-            _ => {
-                /* encrypted, decoded data in decoded_data now ... */
-                if !(0 == has_decrypted_pgp_armor(decoded_data, decoded_data_bytes as libc::c_int))
-                {
-                    let add_signatures = if ret_valid_signatures.is_empty() {
-                        Some(ret_valid_signatures)
-                    } else {
-                        None
-                    };
+        if ok_to_continue {
+            /* encrypted, decoded data in decoded_data now ... */
+            if !(0 == has_decrypted_pgp_armor(decoded_data, decoded_data_bytes as libc::c_int)) {
+                let add_signatures = if ret_valid_signatures.is_empty() {
+                    Some(ret_valid_signatures)
+                } else {
+                    None
+                };
 
-                    /*if we already have fingerprints, do not add more; this ensures, only the fingerprints from the outer-most part are collected */
-                    if let Some(plain) = dc_pgp_pk_decrypt(
-                        decoded_data as *const libc::c_void,
-                        decoded_data_bytes,
-                        &private_keyring,
-                        &public_keyring_for_validate,
-                        add_signatures,
-                    ) {
-                        let plain_bytes = plain.len();
-                        let plain_buf = plain.as_ptr() as *const libc::c_char;
+                /*if we already have fingerprints, do not add more; this ensures, only the fingerprints from the outer-most part are collected */
+                if let Some(plain) = dc_pgp_pk_decrypt(
+                    decoded_data as *const libc::c_void,
+                    decoded_data_bytes,
+                    &private_keyring,
+                    &public_keyring_for_validate,
+                    add_signatures,
+                ) {
+                    let plain_bytes = plain.len();
+                    let plain_buf = plain.as_ptr() as *const libc::c_char;
 
-                        let mut index: size_t = 0i32 as size_t;
-                        let mut decrypted_mime: *mut mailmime = 0 as *mut mailmime;
-                        if mailmime_parse(
-                            plain_buf as *const _,
-                            plain_bytes,
-                            &mut index,
-                            &mut decrypted_mime,
-                        ) != MAIL_NO_ERROR as libc::c_int
-                            || decrypted_mime.is_null()
-                        {
-                            if !decrypted_mime.is_null() {
-                                mailmime_free(decrypted_mime);
-                            }
-                        } else {
-                            *ret_decrypted_mime = decrypted_mime;
-                            sth_decrypted = 1i32
+                    let mut index: size_t = 0i32 as size_t;
+                    let mut decrypted_mime: *mut mailmime = 0 as *mut mailmime;
+                    if mailmime_parse(
+                        plain_buf as *const _,
+                        plain_bytes,
+                        &mut index,
+                        &mut decrypted_mime,
+                    ) != MAIL_NO_ERROR as libc::c_int
+                        || decrypted_mime.is_null()
+                    {
+                        if !decrypted_mime.is_null() {
+                            mailmime_free(decrypted_mime);
                         }
+                    } else {
+                        *ret_decrypted_mime = decrypted_mime;
+                        sth_decrypted = 1i32
                     }
+                    std::mem::forget(plain);
                 }
             }
         }
@@ -1056,25 +1036,150 @@ pub unsafe fn dc_e2ee_thanks(helper: &mut dc_e2ee_helper_t) {
     helper.cdata_to_free = 0 as *mut libc::c_void;
 }
 
-/* makes sure, the private key exists, needed only for exporting keys and the case no message was sent before */
-// TODO should return bool /rtn
-pub unsafe fn dc_ensure_secret_key_exists(context: &Context) -> libc::c_int {
-    /* normally, the key is generated as soon as the first mail is send
-    (this is to gain some extra-random-seed by the message content and the timespan between program start and message sending) */
-    let mut success: libc::c_int = 0i32;
+/// Ensures a private key exists for the configured user.
+///
+/// Normally the private key is generated when the first message is
+/// sent but in a few locations there are no such guarantees,
+/// e.g. when exporting keys, and calling this function ensures a
+/// private key will be present.
+///
+/// If this succeeds you are also guaranteed that the
+/// [Config::ConfiguredAddr] is configured, this address is returned.
+pub fn dc_ensure_secret_key_exists(context: &Context) -> Result<String> {
+    let self_addr = context
+        .get_config(Config::ConfiguredAddr)
+        .ok_or(format_err!(concat!(
+            "Failed to get self address, ",
+            "cannot ensure secret key if not configured."
+        )))?;
+    load_or_generate_self_public_key(context, &self_addr)?;
+    Ok(self_addr)
+}
 
-    let self_addr = context.sql.get_config(context, "configured_addr");
-    if self_addr.is_none() {
-        warn!(
-            context,
-            0, "Cannot ensure secret key if context is not configured.",
-        );
-    } else if load_or_generate_self_public_key(context, self_addr.unwrap(), 0 as *mut mailmime)
-        .is_some()
-    {
-        /*no random text data for seeding available*/
-        success = 1;
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::test_utils::*;
+
+    mod ensure_secret_key_exists {
+        use super::*;
+
+        #[test]
+        fn test_prexisting() {
+            let t = dummy_context();
+            let test_addr = configure_alice_keypair(&t.ctx);
+            assert_eq!(dc_ensure_secret_key_exists(&t.ctx).unwrap(), test_addr);
+        }
+
+        #[test]
+        fn test_not_configured() {
+            let t = dummy_context();
+            assert!(dc_ensure_secret_key_exists(&t.ctx).is_err());
+        }
     }
 
-    success
+    #[test]
+    fn test_mailmime_parse() {
+        let plain = b"Chat-Disposition-Notification-To: holger@deltachat.de
+Chat-Group-ID: CovhGgau8M-
+Chat-Group-Name: Delta Chat Dev
+Subject: =?utf-8?Q?Chat=3A?= Delta Chat =?utf-8?Q?Dev=3A?= sidenote for
+ =?utf-8?Q?all=3A?= rust core master ...
+Content-Type: text/plain; charset=\"utf-8\"; protected-headers=\"v1\"
+Content-Transfer-Encoding: quoted-printable
+
+sidenote for all: rust core master is broken currently ... so dont recomm=
+end to try to run with desktop or ios unless you are ready to hunt bugs
+
+-- =20
+Sent with my Delta Chat Messenger: https://delta.chat";
+        let plain_bytes = plain.len();
+        let plain_buf = plain.as_ptr() as *const libc::c_char;
+
+        let mut index = 0;
+        let mut decrypted_mime = std::ptr::null_mut();
+
+        let res = unsafe {
+            mailmime_parse(
+                plain_buf as *const _,
+                plain_bytes,
+                &mut index,
+                &mut decrypted_mime,
+            )
+        };
+        unsafe {
+            let msg1 = (*decrypted_mime).mm_data.mm_message.mm_msg_mime;
+            let mut decoded_data = 0 as *const libc::c_char;
+            let mut decoded_data_bytes = 0;
+            let mut transfer_decoding_buffer: *mut libc::c_char = 0 as *mut libc::c_char;
+
+            assert_eq!(
+                mailmime_transfer_decode(
+                    msg1,
+                    &mut decoded_data,
+                    &mut decoded_data_bytes,
+                    &mut transfer_decoding_buffer,
+                ),
+                1
+            );
+            println!(
+                "{:?}",
+                String::from_utf8_lossy(std::slice::from_raw_parts(
+                    decoded_data as *const u8,
+                    decoded_data_bytes as usize,
+                ))
+            );
+
+            free(decoded_data as *mut _);
+        }
+
+        assert_eq!(res, 0);
+        assert!(!decrypted_mime.is_null());
+
+        unsafe { free(decrypted_mime as *mut _) };
+    }
+
+    mod load_or_generate_self_public_key {
+        use super::*;
+
+        #[test]
+        fn test_existing() {
+            let t = dummy_context();
+            let addr = configure_alice_keypair(&t.ctx);
+            let key = load_or_generate_self_public_key(&t.ctx, addr);
+            assert!(key.is_ok());
+        }
+
+        #[test]
+        #[ignore] // generating keys is expensive
+        fn test_generate() {
+            let t = dummy_context();
+            let addr = "alice@example.org";
+            let key0 = load_or_generate_self_public_key(&t.ctx, addr);
+            assert!(key0.is_ok());
+            let key1 = load_or_generate_self_public_key(&t.ctx, addr);
+            assert!(key1.is_ok());
+            assert_eq!(key0.unwrap(), key1.unwrap());
+        }
+
+        #[test]
+        #[ignore]
+        fn test_generate_concurrent() {
+            use std::sync::Arc;
+            use std::thread;
+
+            let t = dummy_context();
+            let ctx = Arc::new(t.ctx);
+            let ctx0 = Arc::clone(&ctx);
+            let thr0 =
+                thread::spawn(move || load_or_generate_self_public_key(&ctx0, "alice@example.org"));
+            let ctx1 = Arc::clone(&ctx);
+            let thr1 =
+                thread::spawn(move || load_or_generate_self_public_key(&ctx1, "alice@example.org"));
+            let res0 = thr0.join().unwrap();
+            let res1 = thr1.join().unwrap();
+            assert_eq!(res0.unwrap(), res1.unwrap());
+        }
+    }
 }

src/dc_imex.rs

@@ -194,20 +194,15 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
     setup_code.strdup()
 }
 
+/// Renders HTML body of a setup file message.
+///
+/// The `passphrase` must be at least 2 characters long.
 pub fn dc_render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
     ensure!(
         passphrase.len() >= 2,
         "Passphrase must be at least 2 chars long."
     );
-    unsafe {
-        ensure!(
-            !(dc_ensure_secret_key_exists(context) == 0),
-            "No secret key available."
-        );
-    }
-    let self_addr = context
-        .get_config(Config::ConfiguredAddr)
-        .ok_or(format_err!("Failed to get self address."))?;
+    let self_addr = dc_ensure_secret_key_exists(context)?;
     let private_key = Key::from_self_private(context, self_addr, &context.sql)
         .ok_or(format_err!("Failed to get private key."))?;
     let ac_headers = match context
@@ -326,7 +321,7 @@ pub unsafe fn dc_continue_key_transfer(
                 armored_key = dc_decrypt_setup_file(context, norm_sc, filecontent);
                 if armored_key.is_null() {
                     warn!(context, 0, "Cannot decrypt Autocrypt Setup Message.",);
-                } else if !(0 == set_self_key(context, armored_key, 1i32)) {
+                } else if set_self_key(context, armored_key, 1) {
                     /*set default*/
                     /* error already logged */
                     success = 1i32
@@ -343,12 +338,11 @@ pub unsafe fn dc_continue_key_transfer(
     success
 }
 
-// TODO should return bool /rtn
 fn set_self_key(
     context: &Context,
     armored_c: *const libc::c_char,
     set_default: libc::c_int,
-) -> libc::c_int {
+) -> bool {
     assert!(!armored_c.is_null(), "invalid buffer");
     let armored = as_str(armored_c);
 
@@ -358,7 +352,7 @@ fn set_self_key(
 
     if keys.is_none() {
         error!(context, 0, "File does not contain a valid private key.",);
-        return 0;
+        return false;
     }
 
     let (private_key, public_key, header) = keys.unwrap();
@@ -372,7 +366,7 @@ fn set_self_key(
     )
     .is_err()
     {
-        return 0;
+        return false;
     }
 
     if 0 != set_default {
@@ -384,7 +378,7 @@ fn set_self_key(
         )
         .is_err()
         {
-            return 0;
+            return false;
         }
     } else {
         error!(context, 0, "File does not contain a private key.",);
@@ -394,7 +388,7 @@ fn set_self_key(
 
     if self_addr.is_none() {
         error!(context, 0, "Missing self addr");
-        return 0;
+        return false;
     }
 
     if !dc_key_save_self_keypair(
@@ -406,20 +400,20 @@ fn set_self_key(
         &context.sql,
     ) {
         error!(context, 0, "Cannot save keypair.");
-        return 0;
+        return false;
     }
 
     match preferencrypt.map(|s| s.as_str()) {
-        Some("") => 0,
+        Some("") => false,
         Some("nopreference") => context
             .sql
             .set_config_int(context, "e2ee_enabled", 0)
-            .is_ok() as libc::c_int,
+            .is_ok(),
         Some("mutual") => context
             .sql
             .set_config_int(context, "e2ee_enabled", 1)
-            .is_ok() as libc::c_int,
-        _ => 1,
+            .is_ok(),
+        _ => true,
     }
 }
 
@@ -514,7 +508,7 @@ pub unsafe fn dc_normalize_setup_code(
 
 #[allow(non_snake_case)]
 pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: *mut dc_job_t) {
-    let mut current_block: u64;
+    let mut ok_to_continue = true;
     let mut success: libc::c_int = 0;
     let mut ongoing_allocated_here: libc::c_int = 0;
     let what: libc::c_int;
@@ -522,7 +516,8 @@ pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: *mut dc_job_t)
     if !(0 == dc_alloc_ongoing(context)) {
         ongoing_allocated_here = 1;
         what = (*job).param.get_int(Param::Cmd).unwrap_or_default();
-        let param1 = CString::yolo((*job).param.get(Param::Arg).unwrap_or_default());
+        let param1_s = (*job).param.get(Param::Arg).unwrap_or_default();
+        let param1 = CString::yolo(param1_s);
         let _param2 = CString::yolo((*job).param.get(Param::Arg2).unwrap_or_default());
 
         if strlen(param1.as_ptr()) == 0 {
@@ -535,185 +530,45 @@ pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: *mut dc_job_t)
             } else {
                 if what == 1 || what == 11 {
                     /* before we export anything, make sure the private key exists */
-                    if 0 == dc_ensure_secret_key_exists(context) {
+                    if dc_ensure_secret_key_exists(context).is_err() {
                         error!(
                             context,
                             0,
                             "Import/export: Cannot create private key or private key not available.",
                         );
-                        current_block = 3568988166330621280;
+                        ok_to_continue = false;
                     } else {
-                        dc_create_folder(context, param1.as_ptr());
-                        current_block = 4495394744059808450;
+                        dc_create_folder(context, &param1_s);
                     }
-                } else {
-                    current_block = 4495394744059808450;
                 }
-                match current_block {
-                    3568988166330621280 => {}
-                    _ => match what {
+                if ok_to_continue {
+                    match what {
                         1 => {
-                            current_block = 10991094515395304355;
-                            match current_block {
-                                2973387206439775448 => {
-                                    if 0 == import_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                11250025114629486028 => {
-                                    if 0 == import_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                12669919903773909120 => {
-                                    if 0 == export_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                _ => {
-                                    if 0 == export_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                            }
-                            match current_block {
-                                3568988166330621280 => {}
-                                _ => {
-                                    info!(context, 0, "Import/export completed.",);
-                                    success = 1
-                                }
+                            if 0 != export_self_keys(context, param1.as_ptr()) {
+                                info!(context, 0, "Import/export completed.",);
+                                success = 1
                             }
                         }
                         2 => {
-                            current_block = 11250025114629486028;
-                            match current_block {
-                                2973387206439775448 => {
-                                    if 0 == import_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                11250025114629486028 => {
-                                    if 0 == import_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                12669919903773909120 => {
-                                    if 0 == export_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                _ => {
-                                    if 0 == export_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                            }
-                            match current_block {
-                                3568988166330621280 => {}
-                                _ => {
-                                    info!(context, 0, "Import/export completed.",);
-                                    success = 1
-                                }
+                            if 0 != import_self_keys(context, param1.as_ptr()) {
+                                info!(context, 0, "Import/export completed.",);
+                                success = 1
                             }
                         }
                         11 => {
-                            current_block = 12669919903773909120;
-                            match current_block {
-                                2973387206439775448 => {
-                                    if 0 == import_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                11250025114629486028 => {
-                                    if 0 == import_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                12669919903773909120 => {
-                                    if 0 == export_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                _ => {
-                                    if 0 == export_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                            }
-                            match current_block {
-                                3568988166330621280 => {}
-                                _ => {
-                                    info!(context, 0, "Import/export completed.",);
-                                    success = 1
-                                }
+                            if 0 != export_backup(context, param1.as_ptr()) {
+                                info!(context, 0, "Import/export completed.",);
+                                success = 1
                             }
                         }
                         12 => {
-                            current_block = 2973387206439775448;
-                            match current_block {
-                                2973387206439775448 => {
-                                    if 0 == import_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                11250025114629486028 => {
-                                    if 0 == import_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                12669919903773909120 => {
-                                    if 0 == export_backup(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                                _ => {
-                                    if 0 == export_self_keys(context, param1.as_ptr()) {
-                                        current_block = 3568988166330621280;
-                                    } else {
-                                        current_block = 1118134448028020070;
-                                    }
-                                }
-                            }
-                            match current_block {
-                                3568988166330621280 => {}
-                                _ => {
-                                    info!(context, 0, "Import/export completed.",);
-                                    success = 1
-                                }
+                            if 0 != import_backup(context, param1.as_ptr()) {
+                                info!(context, 0, "Import/export completed.",);
+                                success = 1
                             }
                         }
                         _ => {}
-                    },
+                    }
                 }
             }
         }
@@ -749,8 +604,8 @@ unsafe fn import_backup(context: &Context, backup_to_import: *const libc::c_char
         return 0;
     }
     &context.sql.close(&context);
-    dc_delete_file(context, context.get_dbfile());
-    if 0 != dc_file_exist(context, context.get_dbfile()) {
+    dc_delete_file(context, as_path(context.get_dbfile()));
+    if dc_file_exist(context, as_path(context.get_dbfile())) {
         error!(
             context,
             0, "Cannot import backups: Cannot delete the old file.",
@@ -758,7 +613,11 @@ unsafe fn import_backup(context: &Context, backup_to_import: *const libc::c_char
         return 0;
     }
 
-    if 0 == dc_copy_file(context, backup_to_import, context.get_dbfile()) {
+    if !dc_copy_file(
+        context,
+        as_path(backup_to_import),
+        as_path(context.get_dbfile()),
+    ) {
         return 0;
     }
     /* error already logged */
@@ -885,7 +744,11 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
         as_str(context.get_dbfile()),
         as_str(dest_pathNfilename),
     );
-    if !(0 == dc_copy_file(context, context.get_dbfile(), dest_pathNfilename)) {
+    if dc_copy_file(
+        context,
+        as_path(context.get_dbfile()),
+        as_path(dest_pathNfilename),
+    ) {
         context.sql.open(&context, as_path(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) */
@@ -1045,7 +908,7 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
         context.sql.open(&context, as_path(context.get_dbfile()), 0);
     }
     if 0 != delete_dest_file {
-        dc_delete_file(context, dest_pathNfilename);
+        dc_delete_file(context, as_path(dest_pathNfilename));
     }
     free(dest_pathNfilename as *mut libc::c_void);
 
@@ -1155,7 +1018,7 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) ->
                     );
                     set_default = 0i32
                 }
-                if 0 == set_self_key(context, private_key, set_default) {
+                if !set_self_key(context, private_key, set_default) {
                     continue;
                 }
                 imported_cnt += 1
@@ -1265,7 +1128,7 @@ unsafe fn export_key_to_asc_file(
         )
     }
     info!(context, 0, "Exporting key {}", as_str(file_name),);
-    dc_delete_file(context, file_name);
+    dc_delete_file(context, as_path(file_name));
     if !key.write_asc_to_file(file_name, context) {
         error!(context, 0, "Cannot write key to {}", as_str(file_name),);
     } else {
@@ -1285,147 +1148,15 @@ unsafe fn export_key_to_asc_file(
 mod tests {
     use super::*;
 
-    use std::ffi::CStr;
-
     use num_traits::ToPrimitive;
 
-    use crate::config::Config;
-    use crate::key;
     use crate::test_utils::*;
 
-    unsafe extern "C" fn logging_cb(
-        _ctx: &Context,
-        evt: Event,
-        _d1: uintptr_t,
-        d2: uintptr_t,
-    ) -> uintptr_t {
-        let to_str = |x| CStr::from_ptr(x as *const libc::c_char).to_str().unwrap();
-        match evt {
-            Event::INFO => println!("I: {}", to_str(d2)),
-            Event::WARNING => println!("W: {}", to_str(d2)),
-            Event::ERROR => println!("E: {}", to_str(d2)),
-            _ => (),
-        }
-        0
-    }
-
-    /// Create Alice with a pre-generated keypair.
-    fn create_alice_keypair(ctx: &Context) {
-        ctx.set_config(Config::ConfiguredAddr, Some("alice@example.org"))
-            .unwrap();
-
-        // The keypair was created using:
-        //   let (public, private) = crate::pgp::dc_pgp_create_keypair("alice@example.com")
-        //       .unwrap();
-        //   println!("{}", public.to_base64(64));
-        //   println!("{}", private.to_base64(64));
-        let public = key::Key::from_base64(
-            concat!(
-                "xsBNBF086ewBCACmJKuoxIO6T87yi4Q3MyNpMch3Y8KrtHDQyUszU36eqM3Pmd1l",
-                "FrbcCd8ZWo2pq6OJSwsM/jjRGn1zo2YOaQeJRRrC+KrKGqSUtRSYQBPrPjE2YjSX",
-                "AMbu8jBI6VVUhHeghriBkK79PY9O/oRhIJC0p14IJe6CQ6OI2fTmTUHF9i/nJ3G4",
-                "Wb3/K1bU3yVfyPZjTZQPYPvvh03vxHULKurtYkX5DTEMSWsF4qzLMps+l87VuLV9",
-                "iQnbN7YMRLHHx2KkX5Ivi7JCefhCa54M0K3bDCCxuVWAM5wjQwNZjzR+WL+dYchw",
-                "oFvuF8NrlzjM9dSv+2rn+J7f99ijSXarzPC7ABEBAAHNEzxhbGljZUBleGFtcGxl",
-                "LmNvbT7CwIkEEAEIADMCGQEFAl086fgCGwMECwkIBwYVCAkKCwIDFgIBFiEE+iai",
-                "x4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcei3ogf/cruUmQ+th52TFHTHdkw9",
-                "OHUl3MrXtZ7QmHyOAFvbXE/6n5Eeh+eZoF8MWWV72m14Wbs+vTcNQkFVTdOPptkK",
-                "A8e4cJqwDOHsyAnvQXZ7WNje9+BMzcoipIUawHP4ORFaPDsKLZQ0b4wBbKn8ziea",
-                "6zjGF0/qljTdoxTtsYpv5wXYuhwbYklrLOqgSa5M7LXUe7E3g9mbg+9iX1GuB8m6",
-                "GkquJN814Y+xny4xhZzGOfue6SeP12jJMNSjSP7416dRq7794VGnkkW9V/7oFEUK",
-                "u5wO9FFbgDySOSlEjByGejSGuBmho0iJSjcPjZ7EY/j3M3orq4dpza5C82OeSvxD",
-                "Fc7ATQRdPOnsAQgA5oLxXRLnyugzOmNCy7dxV3JrDZscA6JNlJlDWIShT0YSs+zG",
-                "9JzDeQql+sYXgUSxOoIayItuXtnFn7tstwGoOnYvadm/e5/7V5fKAQRtCtdN51av",
-                "62n18Venlm0yNKpROPcZ6M/sc4m6uU6YRZ/a1idal8VGY0wLKlghjIBuIiBoVQ/R",
-                "noW+/fhmwIg08dQ5m8hQe3GEOZEeLrTWL/9awPlXK7Y+DmJOoR4qbHWEcRfbzS6q",
-                "4zW8vk2ztB8ngwbnqYy8zrN1DCICN1gYdlU++uVw6Bb1XfY8Cdldh1VLKpF35mAm",
-                "jxLZfVDcoObFH3Cv2GB7BEYxv86KC2Y6T74Q/wARAQABwsB2BBgBCAAgBQJdPOn4",
-                "AhsMFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcegLxwf/dXshJnoW",
-                "qEnRsf6rVb9/Mc66ti+NVQLfNd275dybh/QIJdK3NmSxdnTPIEJRVspJywJoupwX",
-                "FNrnHG2Ff6QPvHqI+/oNu986r9d7Z1oQibbLHKt8t6kpOfg/xGxotagJuiCQvR9m",
-                "MjD1DqsdB37SjDxGupZOOJSXWi6KX60IE+uM+QOBfeOZziQwuFmA5wV6RDXIeYJf",
-                "qrcbeXeR1d0nfNpPHQR1gBiqmxNb6KBbdXD2+EXW60axC7D2b1APmzMlammDliPw",
-                "sK9U1rc9nuquEBvGDOJf4K+Dzn+mDCqRpP6uAuQ7RKHyim4uyN0wwKObzPqgJCGw",
-                "jTglkixw+aSTXw=="
-            ),
-            KeyType::Public,
-        )
-        .unwrap();
-        let private = key::Key::from_base64(
-            concat!(
-                "xcLYBF086ewBCACmJKuoxIO6T87yi4Q3MyNpMch3Y8KrtHDQyUszU36eqM3Pmd1l",
-                "FrbcCd8ZWo2pq6OJSwsM/jjRGn1zo2YOaQeJRRrC+KrKGqSUtRSYQBPrPjE2YjSX",
-                "AMbu8jBI6VVUhHeghriBkK79PY9O/oRhIJC0p14IJe6CQ6OI2fTmTUHF9i/nJ3G4",
-                "Wb3/K1bU3yVfyPZjTZQPYPvvh03vxHULKurtYkX5DTEMSWsF4qzLMps+l87VuLV9",
-                "iQnbN7YMRLHHx2KkX5Ivi7JCefhCa54M0K3bDCCxuVWAM5wjQwNZjzR+WL+dYchw",
-                "oFvuF8NrlzjM9dSv+2rn+J7f99ijSXarzPC7ABEBAAEACAChqzVOuErmVRqvcYtq",
-                "m1xt1H+ZjX20z5Sn1fhTLYAcq236AWMqJvwxCXoKlc8bt2UfB+Ls9cQb1YcVq353",
-                "r0QiExiDeK3YlCxqd/peXJwFYTNKFC3QcnUhtpG9oS/jWjN+BRotGbjtu6Vj3M68",
-                "JJAq+mHJ0/9OyrqrREvGfo7uLZt7iMGemDlrDakvrbIyZrPLgay+nZ3dEFKeOQ6F",
-                "FrU05jyUVdoHBy0Tqx/6VpFUX9+IHcMHL2lTJB0nynBj+XZ/G4aX3WYoo3YlixHb",
-                "Iu35fGFA0TChoGaGPzqcI/kg2Z+b/BryG9NM3LA2cO8iGrGXAE1nPFp91jmCrQ3V",
-                "WushBADERP+uojjjfdO5J+RkmcFe9mFYDdtkhN+kV+LdePjiNNtcXMBhasstio0S",
-                "ut0GKnE7DFRhX7mkN9w2apJ2ooeFeVVWot18eSdp6Rzh6/1Z7TmhYFJ3oUxxLbnQ",
-                "sWIXIec1SzqWBFJUCn3IP0mCnJktFg/uGW6yLs01r5ds52uSBQQA2LSWiTwk9tEm",
-                "dr9mz3tHnmrkyGiyKhKGM1Z7Rch63D5yQc1s4kUMBlyuLL2QtM/e4dtaz2JAkO8k",
-                "QrYCnNgJ+2roTAK3kDZgYtymjdvK3HpQNtjVo7dds5RJVb6U618phZwU5WNFAEJW",
-                "yyImmycGfjLv+18cW/3mq0QVZejkM78D/2kHaIeJAowtBOFY2zDrKyDRoBHaUSgj",
-                "5BjGoviRC5rYihWDEyYDQ6mBJQstAD0Ty3MYzyUxl6ruB/BMWnMDFq5+TqtdBzu3",
-                "jCtZ8OEyH8A5Kdo68Wzo/PGxzMtusOdNj9+3PBmSq4yibJxbLSrn59aVUYpGLjeG",
-                "Kyvm9OTKkrOGN27NEzxhbGljZUBleGFtcGxlLmNvbT7CwIkEEAEIADMCGQEFAl08",
-                "6fgCGwMECwkIBwYVCAkKCwIDFgIBFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQ",
-                "k6DcNkbrcei3ogf/cruUmQ+th52TFHTHdkw9OHUl3MrXtZ7QmHyOAFvbXE/6n5Ee",
-                "h+eZoF8MWWV72m14Wbs+vTcNQkFVTdOPptkKA8e4cJqwDOHsyAnvQXZ7WNje9+BM",
-                "zcoipIUawHP4ORFaPDsKLZQ0b4wBbKn8ziea6zjGF0/qljTdoxTtsYpv5wXYuhwb",
-                "YklrLOqgSa5M7LXUe7E3g9mbg+9iX1GuB8m6GkquJN814Y+xny4xhZzGOfue6SeP",
-                "12jJMNSjSP7416dRq7794VGnkkW9V/7oFEUKu5wO9FFbgDySOSlEjByGejSGuBmh",
-                "o0iJSjcPjZ7EY/j3M3orq4dpza5C82OeSvxDFcfC2ARdPOnsAQgA5oLxXRLnyugz",
-                "OmNCy7dxV3JrDZscA6JNlJlDWIShT0YSs+zG9JzDeQql+sYXgUSxOoIayItuXtnF",
-                "n7tstwGoOnYvadm/e5/7V5fKAQRtCtdN51av62n18Venlm0yNKpROPcZ6M/sc4m6",
-                "uU6YRZ/a1idal8VGY0wLKlghjIBuIiBoVQ/RnoW+/fhmwIg08dQ5m8hQe3GEOZEe",
-                "LrTWL/9awPlXK7Y+DmJOoR4qbHWEcRfbzS6q4zW8vk2ztB8ngwbnqYy8zrN1DCIC",
-                "N1gYdlU++uVw6Bb1XfY8Cdldh1VLKpF35mAmjxLZfVDcoObFH3Cv2GB7BEYxv86K",
-                "C2Y6T74Q/wARAQABAAgAhSvFEYZoj1sSrXrHDjZOrryViGjCCH9t3pmkxLDrGIdd",
-                "KsFyN8ORUo6KUZS745yx3yFnI9EZ1IZvm9aF+jxk2lGJFtgLvfoxFOvGckwCSy8T",
-                "/MCiJZkz01hWo5s2VCLJheWL/GqTKjS5wXDcm+y8Wtilh+UawycdlDsSNr/D4MZL",
-                "j3Chq9K03l5UIR8DcC7SavNi55R2oGOfboXsdvwOlrNZdCkZOlXDI4ZKFwbDHCtp",
-                "Do5FS30hnJi2TecUPZWB1CaGFWnevINd4ikugVjcAoZj/QAIvfrOCgqisF/Ylg9u",
-                "RMUPBapmcJUueILwd0iQqvGG0aCqtchvSmlg15/lQQQA9G1NNjNAH+NQrXvDJFJe",
-                "/V1U3F3pz7jCjQa69c0dxSBUeNX1pG8XXD6tSkkd4Ni1mzZGcZXOmVUM6cA9I7RH",
-                "95RqV+QIfnXVneCRrlCjV8m6OBlkivkESXc3nW5wtCIfw7oKg9w1xuVNUaAlbCt9",
-                "QVLaxXJiY7ad0f5U9XJ1+w8EAPFs+M/+GZK1wOZYBL1vo7x0gL9ZggmjC4B+viBJ",
-                "8Q60mqTrphYFsbXHuwKV0g9aIoZMucKyEE0QLR7imttiLEz1nD8bfEScbGy9ZG//",
-                "wRfyJmCVAjA0pQ6LtB93d70PSVzzJrMHgbLKrDuSd6RChl7n9BIEdVyk7LEph0Yg",
-                "9UsRBADm6DvpKL+P3lQ0eLTfAgcQTOqLZDYmI3PvqqSkHb1kHChqOXXs8hGOSSwK",
-                "Gjcd4CZeNOGWR42rZyRhVgtkt6iYviIaVAWUfme6K+sLQBCeyMlmEGtykAA+LmPB",
-                "f4zdyUNADfoxgZF3EKHf6I3nlVn5cdT+o/9vjdY2XAOwcls1RzaFwsB2BBgBCAAg",
-                "BQJdPOn4AhsMFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcegLxwf/",
-                "dXshJnoWqEnRsf6rVb9/Mc66ti+NVQLfNd275dybh/QIJdK3NmSxdnTPIEJRVspJ",
-                "ywJoupwXFNrnHG2Ff6QPvHqI+/oNu986r9d7Z1oQibbLHKt8t6kpOfg/xGxotagJ",
-                "uiCQvR9mMjD1DqsdB37SjDxGupZOOJSXWi6KX60IE+uM+QOBfeOZziQwuFmA5wV6",
-                "RDXIeYJfqrcbeXeR1d0nfNpPHQR1gBiqmxNb6KBbdXD2+EXW60axC7D2b1APmzMl",
-                "ammDliPwsK9U1rc9nuquEBvGDOJf4K+Dzn+mDCqRpP6uAuQ7RKHyim4uyN0wwKOb",
-                "zPqgJCGwjTglkixw+aSTXw=="
-            ),
-            KeyType::Private,
-        )
-        .unwrap();
-        let saved = key::dc_key_save_self_keypair(
-            &ctx,
-            &public,
-            &private,
-            "alice@example.org",
-            1,
-            &ctx.sql,
-        );
-        assert_eq!(saved, true, "Failed to save Alice's key");
-    }
-
     #[test]
     fn test_render_setup_file() {
         let t = test_context(Some(logging_cb));
 
-        create_alice_keypair(&t.ctx); // Trick things to think we're configured.
+        configure_alice_keypair(&t.ctx);
         let msg = dc_render_setup_file(&t.ctx, "hello").unwrap();
         println!("{}", &msg);
         // Check some substrings, indicating things got substituted.
@@ -1457,7 +1188,7 @@ mod tests {
     #[test]
     fn test_render_setup_file_newline_replace() {
         let t = test_context(Some(ac_setup_msg_cb));
-        create_alice_keypair(&t.ctx);
+        configure_alice_keypair(&t.ctx);
         let msg = dc_render_setup_file(&t.ctx, "pw").unwrap();
         println!("{}", &msg);
         assert!(msg.contains("<p>hello<br>there</p>"));

src/dc_job.rs

@@ -17,7 +17,6 @@ use crate::dc_mimefactory::*;
 use crate::dc_msg::*;
 use crate::dc_tools::*;
 use crate::imap::*;
-use crate::keyhistory::*;
 use crate::param::*;
 use crate::sql;
 use crate::types::*;
@@ -293,7 +292,7 @@ unsafe fn dc_suspend_smtp_thread(context: &Context, suspend: bool) {
 
 #[allow(non_snake_case)]
 unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
-    let mut current_block: u64;
+    let ok_to_continue;
     let mut filename: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut buf: *mut libc::c_void = 0 as *mut libc::c_void;
     let mut buf_bytes: size_t = 0i32 as size_t;
@@ -305,100 +304,89 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
 
         if !connected {
             dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-            current_block = 14216916617354591294;
+            ok_to_continue = false;
         } else {
-            current_block = 13109137661213826276;
+            ok_to_continue = true;
         }
     } else {
-        current_block = 13109137661213826276;
+        ok_to_continue = true;
     }
-    match current_block {
-        13109137661213826276 => {
-            filename = job.param.get(Param::File).unwrap_or_default().strdup();
-            if strlen(filename) == 0 {
-                warn!(context, 0, "Missing file name for job {}", job.job_id,);
-            } else if !(0 == dc_read_file(context, filename, &mut buf, &mut buf_bytes)) {
-                let recipients = job.param.get(Param::Recipients);
-                if recipients.is_none() {
-                    warn!(context, 0, "Missing recipients for job {}", job.job_id,);
-                } else {
-                    let recipients_list = recipients
-                        .unwrap()
-                        .split("\x1e")
-                        .filter_map(|addr| match lettre::EmailAddress::new(addr.to_string()) {
-                            Ok(addr) => Some(addr),
-                            Err(err) => {
-                                eprintln!("WARNING: invalid recipient: {} {:?}", addr, err);
-                                None
-                            }
-                        })
-                        .collect::<Vec<_>>();
-                    /* if there is a msg-id and it does not exist in the db, cancel sending.
-                    this happends if dc_delete_msgs() was called
-                    before the generated mime was sent out */
-                    if 0 != job.foreign_id {
-                        if 0 == dc_msg_exists(context, job.foreign_id) {
-                            warn!(
-                                context,
-                                0,
-                                "Message {} for job {} does not exist",
-                                job.foreign_id,
-                                job.job_id,
-                            );
-                            current_block = 14216916617354591294;
-                        } else {
-                            current_block = 11194104282611034094;
+    if ok_to_continue {
+        let filename_s = job.param.get(Param::File).unwrap_or_default();
+        filename = filename_s.strdup();
+        if strlen(filename) == 0 {
+            warn!(context, 0, "Missing file name for job {}", job.job_id,);
+        } else if !(0 == dc_read_file(context, filename, &mut buf, &mut buf_bytes)) {
+            let recipients = job.param.get(Param::Recipients);
+            if recipients.is_none() {
+                warn!(context, 0, "Missing recipients for job {}", job.job_id,);
+            } else {
+                let recipients_list = recipients
+                    .unwrap()
+                    .split("\x1e")
+                    .filter_map(|addr| match lettre::EmailAddress::new(addr.to_string()) {
+                        Ok(addr) => Some(addr),
+                        Err(err) => {
+                            eprintln!("WARNING: invalid recipient: {} {:?}", addr, err);
+                            None
                         }
+                    })
+                    .collect::<Vec<_>>();
+                /* if there is a msg-id and it does not exist in the db, cancel sending.
+                this happends if dc_delete_msgs() was called
+                before the generated mime was sent out */
+                let ok_to_continue1;
+                if 0 != job.foreign_id {
+                    if 0 == dc_msg_exists(context, job.foreign_id) {
+                        warn!(
+                            context,
+                            0, "Message {} for job {} does not exist", job.foreign_id, job.job_id,
+                        );
+                        ok_to_continue1 = false;
                     } else {
-                        current_block = 11194104282611034094;
+                        ok_to_continue1 = true;
                     }
-                    match current_block {
-                        14216916617354591294 => {}
-                        _ => {
-                            /* send message */
-                            let body =
-                                std::slice::from_raw_parts(buf as *const u8, buf_bytes).to_vec();
-                            if 0 == context.smtp.lock().unwrap().send(
-                                context,
-                                recipients_list,
-                                body,
-                            ) {
-                                context.smtp.lock().unwrap().disconnect();
-                                dc_job_try_again_later(
-                                    job,
-                                    -1i32,
-                                    (*&mut context.smtp.clone().lock().unwrap()).error,
-                                );
-                            } else {
-                                dc_delete_file(context, filename);
-                                if 0 != job.foreign_id {
-                                    dc_update_msg_state(
-                                        context,
-                                        job.foreign_id,
-                                        DC_STATE_OUT_DELIVERED,
-                                    );
-                                    let chat_id: i32 = context
-                                        .sql
-                                        .query_row_col(
-                                            context,
-                                            "SELECT chat_id FROM msgs WHERE id=?",
-                                            params![job.foreign_id as i32],
-                                            0,
-                                        )
-                                        .unwrap_or_default();
-                                    context.call_cb(
-                                        Event::MSG_DELIVERED,
-                                        chat_id as uintptr_t,
-                                        job.foreign_id as uintptr_t,
-                                    );
-                                }
-                            }
+                } else {
+                    ok_to_continue1 = true;
+                }
+                if ok_to_continue1 {
+                    /* send message */
+                    let body = std::slice::from_raw_parts(buf as *const u8, buf_bytes).to_vec();
+                    if 0 == context
+                        .smtp
+                        .lock()
+                        .unwrap()
+                        .send(context, recipients_list, body)
+                    {
+                        context.smtp.lock().unwrap().disconnect();
+                        dc_job_try_again_later(
+                            job,
+                            -1i32,
+                            (*&mut context.smtp.clone().lock().unwrap()).error,
+                        );
+                    } else {
+                        dc_delete_file(context, filename_s);
+                        if 0 != job.foreign_id {
+                            dc_update_msg_state(context, job.foreign_id, DC_STATE_OUT_DELIVERED);
+                            let chat_id: i32 = context
+                                .sql
+                                .query_row_col(
+                                    context,
+                                    "SELECT chat_id FROM msgs WHERE id=?",
+                                    params![job.foreign_id as i32],
+                                    0,
+                                )
+                                .unwrap_or_default();
+                            context.call_cb(
+                                Event::MSG_DELIVERED,
+                                chat_id as uintptr_t,
+                                job.foreign_id as uintptr_t,
+                            );
                         }
                     }
                 }
             }
         }
-        _ => {}
     }
     free(buf);
     free(filename as *mut libc::c_void);
@@ -417,7 +405,7 @@ pub unsafe fn dc_job_try_again_later(
 
 #[allow(non_snake_case)]
 unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
-    let mut current_block: u64;
+    let ok_to_continue;
     let msg = dc_msg_new_untyped(context);
     let mut dest_uid: uint32_t = 0i32 as uint32_t;
 
@@ -427,75 +415,46 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
         connect_to_inbox(context, &inbox);
         if !inbox.is_connected() {
             dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-            current_block = 2238328302157162973;
+            ok_to_continue = false;
         } else {
-            current_block = 2473556513754201174;
+            ok_to_continue = true;
         }
     } else {
-        current_block = 2473556513754201174;
+        ok_to_continue = true;
     }
-    match current_block {
-        2473556513754201174 => {
-            if dc_msg_load_from_db(msg, context, job.foreign_id) {
-                if context
-                    .sql
-                    .get_config_int(context, "folders_configured")
-                    .unwrap_or_default()
-                    < 3
+    if ok_to_continue {
+        if dc_msg_load_from_db(msg, context, job.foreign_id) {
+            if context
+                .sql
+                .get_config_int(context, "folders_configured")
+                .unwrap_or_default()
+                < 3
+            {
+                inbox.configure_folders(context, 0x1i32);
+            }
+            let dest_folder = context.sql.get_config(context, "configured_mvbox_folder");
+
+            if let Some(dest_folder) = dest_folder {
+                let server_folder = (*msg).server_folder.as_ref().unwrap();
+
+                match inbox.mv(
+                    context,
+                    server_folder,
+                    (*msg).server_uid,
+                    &dest_folder,
+                    &mut dest_uid,
+                ) as libc::c_uint
                 {
-                    inbox.configure_folders(context, 0x1i32);
-                }
-                let dest_folder = context.sql.get_config(context, "configured_mvbox_folder");
-
-                if let Some(dest_folder) = dest_folder {
-                    let server_folder = as_str((*msg).server_folder);
-
-                    match inbox.mv(
-                        context,
-                        server_folder,
-                        (*msg).server_uid,
-                        &dest_folder,
-                        &mut dest_uid,
-                    ) as libc::c_uint
-                    {
-                        1 => {
-                            current_block = 6379107252614456477;
-                            match current_block {
-                                12072121998757195963 => {
-                                    dc_update_server_uid(
-                                        context,
-                                        (*msg).rfc724_mid,
-                                        &dest_folder,
-                                        dest_uid,
-                                    );
-                                }
-                                _ => {
-                                    dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-                                }
-                            }
-                        }
-                        3 => {
-                            current_block = 12072121998757195963;
-                            match current_block {
-                                12072121998757195963 => {
-                                    dc_update_server_uid(
-                                        context,
-                                        (*msg).rfc724_mid,
-                                        &dest_folder,
-                                        dest_uid,
-                                    );
-                                }
-                                _ => {
-                                    dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-                                }
-                            }
-                        }
-                        0 | 2 | _ => {}
+                    1 => {
+                        dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
                     }
+                    3 => {
+                        dc_update_server_uid(context, (*msg).rfc724_mid, &dest_folder, dest_uid);
+                    }
+                    0 | 2 | _ => {}
                 }
             }
         }
-        _ => {}
     }
 
     dc_msg_unref(msg);
@@ -514,7 +473,7 @@ fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
 
 #[allow(non_snake_case)]
 unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_job_t) {
-    let current_block: u64;
+    let ok_to_continue;
     let folder = job
         .param
         .get(Param::ServerFolder)
@@ -528,44 +487,39 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_
         connect_to_inbox(context, &inbox);
         if !inbox.is_connected() {
             dc_job_try_again_later(job, 3, 0 as *const libc::c_char);
-            current_block = 2670689566614003383;
+            ok_to_continue = false;
         } else {
-            current_block = 11006700562992250127;
+            ok_to_continue = true;
         }
     } else {
-        current_block = 11006700562992250127;
+        ok_to_continue = true;
     }
-    match current_block {
-        11006700562992250127 => {
-            if inbox.set_seen(context, &folder, uid) == 0 {
-                dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
+    if ok_to_continue {
+        if inbox.set_seen(context, &folder, uid) == 0 {
+            dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
+        }
+        if 0 != job.param.get_int(Param::AlsoMove).unwrap_or_default() {
+            if context
+                .sql
+                .get_config_int(context, "folders_configured")
+                .unwrap_or_default()
+                < 3
+            {
+                inbox.configure_folders(context, 0x1i32);
             }
-            if 0 != job.param.get_int(Param::AlsoMove).unwrap_or_default() {
-                if context
-                    .sql
-                    .get_config_int(context, "folders_configured")
-                    .unwrap_or_default()
-                    < 3
-                {
-                    inbox.configure_folders(context, 0x1i32);
-                }
-                let dest_folder = context.sql.get_config(context, "configured_mvbox_folder");
-                if let Some(dest_folder) = dest_folder {
-                    if 1 == inbox.mv(context, folder, uid, dest_folder, &mut dest_uid)
-                        as libc::c_uint
-                    {
-                        dc_job_try_again_later(job, 3, 0 as *const libc::c_char);
-                    }
+            let dest_folder = context.sql.get_config(context, "configured_mvbox_folder");
+            if let Some(dest_folder) = dest_folder {
+                if 1 == inbox.mv(context, folder, uid, dest_folder, &mut dest_uid) as libc::c_uint {
+                    dc_job_try_again_later(job, 3, 0 as *const libc::c_char);
                 }
             }
         }
-        _ => {}
     }
 }
 
 #[allow(non_snake_case)]
 unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_job_t) {
-    let mut current_block: u64;
+    let ok_to_continue;
     let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let inbox = context.inbox.read().unwrap();
 
@@ -573,132 +527,44 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_
         connect_to_inbox(context, &inbox);
         if !inbox.is_connected() {
             dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-            current_block = 17792648348530113339;
+            ok_to_continue = false;
         } else {
-            current_block = 15240798224410183470;
+            ok_to_continue = true;
         }
     } else {
-        current_block = 15240798224410183470;
+        ok_to_continue = true;
     }
-    match current_block {
-        15240798224410183470 => {
-            if dc_msg_load_from_db(msg, context, job.foreign_id) {
-                let server_folder = CStr::from_ptr((*msg).server_folder).to_str().unwrap();
-                match inbox.set_seen(context, server_folder, (*msg).server_uid) as libc::c_uint {
-                    0 => {}
-                    1 => {
-                        current_block = 12392248546350854223;
-                        match current_block {
-                            12392248546350854223 => {
-                                dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-                            }
-                            _ => {
-                                if 0 != (*msg).param.get_int(Param::WantsMdn).unwrap_or_default()
-                                    && 0 != context
-                                        .sql
-                                        .get_config_int(context, "mdns_enabled")
-                                        .unwrap_or_else(|| 1)
-                                {
-                                    let folder =
-                                        CStr::from_ptr((*msg).server_folder).to_str().unwrap();
-                                    match inbox.set_mdnsent(context, folder, (*msg).server_uid)
-                                        as libc::c_uint
-                                    {
-                                        1 => {
-                                            current_block = 4016212065805849280;
-                                            match current_block {
-                                                6186957421461061791 => {
-                                                    dc_send_mdn(context, (*msg).id);
-                                                }
-                                                _ => {
-                                                    dc_job_try_again_later(
-                                                        job,
-                                                        3i32,
-                                                        0 as *const libc::c_char,
-                                                    );
-                                                }
-                                            }
-                                        }
-                                        3 => {
-                                            current_block = 6186957421461061791;
-                                            match current_block {
-                                                6186957421461061791 => {
-                                                    dc_send_mdn(context, (*msg).id);
-                                                }
-                                                _ => {
-                                                    dc_job_try_again_later(
-                                                        job,
-                                                        3i32,
-                                                        0 as *const libc::c_char,
-                                                    );
-                                                }
-                                            }
-                                        }
-                                        0 | 2 | _ => {}
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    _ => {
-                        current_block = 7746791466490516765;
-                        match current_block {
-                            12392248546350854223 => {
-                                dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-                            }
-                            _ => {
-                                if 0 != (*msg).param.get_int(Param::WantsMdn).unwrap_or_default()
-                                    && 0 != context
-                                        .sql
-                                        .get_config_int(context, "mdns_enabled")
-                                        .unwrap_or_else(|| 1)
-                                {
-                                    let folder =
-                                        CStr::from_ptr((*msg).server_folder).to_str().unwrap();
+    if ok_to_continue {
+        if dc_msg_load_from_db(msg, context, job.foreign_id) {
+            let server_folder = (*msg).server_folder.as_ref().unwrap();
+            match inbox.set_seen(context, server_folder, (*msg).server_uid) as libc::c_uint {
+                0 => {}
+                1 => {
+                    dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
+                }
+                _ => {
+                    if 0 != (*msg).param.get_int(Param::WantsMdn).unwrap_or_default()
+                        && 0 != context
+                            .sql
+                            .get_config_int(context, "mdns_enabled")
+                            .unwrap_or_else(|| 1)
+                    {
+                        let folder = (*msg).server_folder.as_ref().unwrap();
 
-                                    match inbox.set_mdnsent(context, folder, (*msg).server_uid)
-                                        as libc::c_uint
-                                    {
-                                        1 => {
-                                            current_block = 4016212065805849280;
-                                            match current_block {
-                                                6186957421461061791 => {
-                                                    dc_send_mdn(context, (*msg).id);
-                                                }
-                                                _ => {
-                                                    dc_job_try_again_later(
-                                                        job,
-                                                        3i32,
-                                                        0 as *const libc::c_char,
-                                                    );
-                                                }
-                                            }
-                                        }
-                                        3 => {
-                                            current_block = 6186957421461061791;
-                                            match current_block {
-                                                6186957421461061791 => {
-                                                    dc_send_mdn(context, (*msg).id);
-                                                }
-                                                _ => {
-                                                    dc_job_try_again_later(
-                                                        job,
-                                                        3i32,
-                                                        0 as *const libc::c_char,
-                                                    );
-                                                }
-                                            }
-                                        }
-                                        0 | 2 | _ => {}
-                                    }
-                                }
+                        match inbox.set_mdnsent(context, folder, (*msg).server_uid) as libc::c_uint
+                        {
+                            1 => {
+                                dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
                             }
+                            3 => {
+                                dc_send_mdn(context, (*msg).id);
+                            }
+                            0 | 2 | _ => {}
                         }
                     }
                 }
             }
         }
-        _ => {}
     }
     dc_msg_unref(msg);
 }
@@ -787,7 +653,7 @@ unsafe fn dc_add_smtp_job(
             b"\x1e\x00" as *const u8 as *const libc::c_char,
         );
         param.set(Param::File, as_str(pathNfilename));
-        param.set(Param::File, as_str(recipients));
+        param.set(Param::Recipients, as_str(recipients));
         dc_job_add(
             context,
             action,
@@ -865,7 +731,6 @@ pub unsafe fn dc_interrupt_imap_idle(context: &Context) {
 
 #[allow(non_snake_case)]
 unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context: &Context, job: &mut dc_job_t) {
-    let mut current_block: u64;
     let mut delete_from_server: libc::c_int = 1i32;
     let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let inbox = context.inbox.read().unwrap();
@@ -874,6 +739,7 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context: &Context, job: &mut dc_jo
         || (*msg).rfc724_mid.is_null()
         || *(*msg).rfc724_mid.offset(0isize) as libc::c_int == 0i32)
     {
+        let ok_to_continue1;
         /* eg. device messages have no Message-ID */
         if dc_rfc724_mid_cnt(context, (*msg).rfc724_mid) != 1i32 {
             info!(
@@ -884,38 +750,35 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context: &Context, job: &mut dc_jo
         }
         /* if this is the last existing part of the message, we delete the message from the server */
         if 0 != delete_from_server {
+            let ok_to_continue;
             if !inbox.is_connected() {
                 connect_to_inbox(context, &inbox);
                 if !inbox.is_connected() {
                     dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
-                    current_block = 8913536887710889399;
+                    ok_to_continue = false;
                 } else {
-                    current_block = 5399440093318478209;
+                    ok_to_continue = true;
                 }
             } else {
-                current_block = 5399440093318478209;
+                ok_to_continue = true;
             }
-            match current_block {
-                8913536887710889399 => {}
-                _ => {
-                    let mid = CStr::from_ptr((*msg).rfc724_mid).to_str().unwrap();
-                    let server_folder = CStr::from_ptr((*msg).server_folder).to_str().unwrap();
-                    if 0 == inbox.delete_msg(context, mid, server_folder, &mut (*msg).server_uid) {
-                        dc_job_try_again_later(job, -1i32, 0 as *const libc::c_char);
-                        current_block = 8913536887710889399;
-                    } else {
-                        current_block = 17407779659766490442;
-                    }
+            if ok_to_continue {
+                let mid = CStr::from_ptr((*msg).rfc724_mid).to_str().unwrap();
+                let server_folder = (*msg).server_folder.as_ref().unwrap();
+                if 0 == inbox.delete_msg(context, mid, server_folder, &mut (*msg).server_uid) {
+                    dc_job_try_again_later(job, -1i32, 0 as *const libc::c_char);
+                    ok_to_continue1 = false;
+                } else {
+                    ok_to_continue1 = true;
                 }
+            } else {
+                ok_to_continue1 = false;
             }
         } else {
-            current_block = 17407779659766490442;
+            ok_to_continue1 = true;
         }
-        match current_block {
-            8913536887710889399 => {}
-            _ => {
-                dc_delete_msg_from_db(context, (*msg).id);
-            }
+        if ok_to_continue1 {
+            dc_delete_msg_from_db(context, (*msg).id);
         }
     }
     dc_msg_unref(msg);
@@ -1277,13 +1140,6 @@ pub unsafe fn dc_job_send_msg(context: &Context, msg_id: uint32_t) -> libc::c_in
                 (*mimefactory.msg).param.set_int(Param::GuranteeE2ee, 1);
                 dc_msg_save_param_to_disk(mimefactory.msg);
             }
-            dc_add_to_keyhistory(
-                context,
-                0 as *const libc::c_char,
-                0,
-                0 as *const libc::c_char,
-                0 as *const libc::c_char,
-            );
             success = dc_add_smtp_job(context, 5901i32, &mut mimefactory);
         }
     }

src/dc_location.rs

@@ -100,9 +100,8 @@ pub unsafe fn dc_send_locations_to_chat(
         {
             if 0 != seconds && !is_sending_locations_before {
                 msg = dc_msg_new(context, Viewtype::Text);
-                (*msg).text = context
-                    .stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0)
-                    .strdup();
+                (*msg).text =
+                    Some(context.stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0));
                 (*msg).param.set_int(Param::Cmd, 8);
                 dc_send_msg(context, chat_id, msg);
             } else if 0 == seconds && is_sending_locations_before {

src/dc_lot.rs

@@ -1,6 +1,6 @@
+use crate::contact::*;
 use crate::context::Context;
 use crate::dc_chat::*;
-use crate::dc_contact::*;
 use crate::dc_msg::*;
 use crate::dc_tools::*;
 use crate::stock::StockMessage;
@@ -11,7 +11,6 @@ use crate::x::*;
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct dc_lot_t {
-    pub magic: uint32_t,
     pub text1_meaning: libc::c_int,
     pub text1: *mut libc::c_char,
     pub text2: *mut libc::c_char,
@@ -38,14 +37,13 @@ pub unsafe fn dc_lot_new() -> *mut dc_lot_t {
     lot = calloc(1, ::std::mem::size_of::<dc_lot_t>()) as *mut dc_lot_t;
     assert!(!lot.is_null());
 
-    (*lot).magic = 0x107107i32 as uint32_t;
     (*lot).text1_meaning = 0i32;
 
     lot
 }
 
 pub unsafe fn dc_lot_empty(mut lot: *mut dc_lot_t) {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
+    if lot.is_null() {
         return;
     }
     free((*lot).text1 as *mut libc::c_void);
@@ -64,17 +62,16 @@ pub unsafe fn dc_lot_empty(mut lot: *mut dc_lot_t) {
     (*lot).id = 0i32 as uint32_t;
 }
 
-pub unsafe fn dc_lot_unref(mut set: *mut dc_lot_t) {
-    if set.is_null() || (*set).magic != 0x107107i32 as libc::c_uint {
+pub unsafe fn dc_lot_unref(set: *mut dc_lot_t) {
+    if set.is_null() {
         return;
     }
     dc_lot_empty(set);
-    (*set).magic = 0i32 as uint32_t;
     free(set as *mut libc::c_void);
 }
 
 pub unsafe fn dc_lot_get_text1(lot: *const dc_lot_t) -> *mut libc::c_char {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
+    if lot.is_null() {
         return 0 as *mut libc::c_char;
     }
 
@@ -82,7 +79,7 @@ pub unsafe fn dc_lot_get_text1(lot: *const dc_lot_t) -> *mut libc::c_char {
 }
 
 pub unsafe fn dc_lot_get_text2(lot: *const dc_lot_t) -> *mut libc::c_char {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
+    if lot.is_null() {
         return 0 as *mut libc::c_char;
     }
 
@@ -90,7 +87,7 @@ pub unsafe fn dc_lot_get_text2(lot: *const dc_lot_t) -> *mut libc::c_char {
 }
 
 pub unsafe fn dc_lot_get_text1_meaning(lot: *const dc_lot_t) -> libc::c_int {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
+    if lot.is_null() {
         return 0i32;
     }
 
@@ -98,7 +95,7 @@ pub unsafe fn dc_lot_get_text1_meaning(lot: *const dc_lot_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_lot_get_state(lot: *const dc_lot_t) -> libc::c_int {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
+    if lot.is_null() {
         return 0i32;
     }
 
@@ -106,7 +103,7 @@ pub unsafe fn dc_lot_get_state(lot: *const dc_lot_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_lot_get_id(lot: *const dc_lot_t) -> uint32_t {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
+    if lot.is_null() {
         return 0i32 as uint32_t;
     }
 
@@ -114,7 +111,7 @@ pub unsafe fn dc_lot_get_id(lot: *const dc_lot_t) -> uint32_t {
 }
 
 pub unsafe fn dc_lot_get_timestamp(lot: *const dc_lot_t) -> i64 {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
+    if lot.is_null() {
         return 0;
     }
 
@@ -127,10 +124,10 @@ pub unsafe fn dc_lot_fill(
     mut lot: *mut dc_lot_t,
     msg: *mut dc_msg_t,
     chat: *const Chat,
-    contact: *const dc_contact_t,
+    contact: Option<&Contact>,
     context: &Context,
 ) {
-    if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint || msg.is_null() {
+    if lot.is_null() || msg.is_null() {
         return;
     }
     if (*msg).state == 19i32 {
@@ -148,20 +145,37 @@ pub unsafe fn dc_lot_fill(
         (*lot).text1 = 0 as *mut libc::c_char;
         (*lot).text1_meaning = 0i32
     } else if (*chat).type_0 == 120i32 || (*chat).type_0 == 130i32 {
-        if 0 != dc_msg_is_info(msg) || contact.is_null() {
+        if 0 != dc_msg_is_info(msg) || contact.is_none() {
             (*lot).text1 = 0 as *mut libc::c_char;
             (*lot).text1_meaning = 0i32
         } else {
             if !chat.is_null() && (*chat).id == 1i32 as libc::c_uint {
-                (*lot).text1 = dc_contact_get_display_name(contact)
+                if let Some(contact) = contact {
+                    (*lot).text1 = contact.get_display_name().strdup();
+                } else {
+                    (*lot).text1 = std::ptr::null_mut();
+                }
             } else {
-                (*lot).text1 = dc_contact_get_first_name(contact)
+                if let Some(contact) = contact {
+                    (*lot).text1 = contact.get_first_name().strdup();
+                } else {
+                    (*lot).text1 = std::ptr::null_mut();
+                }
             }
-            (*lot).text1_meaning = 2i32
+            (*lot).text1_meaning = 2i32;
         }
     }
-    (*lot).text2 =
-        dc_msg_get_summarytext_by_raw((*msg).type_0, (*msg).text, &mut (*msg).param, 160, context);
+
+    let message_text = (*msg).text.as_ref().unwrap();
+
+    (*lot).text2 = dc_msg_get_summarytext_by_raw(
+        (*msg).type_0,
+        message_text.strdup(),
+        &mut (*msg).param,
+        160,
+        context,
+    );
+
     (*lot).timestamp = dc_msg_get_timestamp(msg);
     (*lot).state = (*msg).state;
 }

src/dc_mimefactory.rs

@@ -9,11 +9,12 @@ use mmime::mailmime_types_helper::*;
 use mmime::mailmime_write_mem::*;
 use mmime::mmapstring::*;
 use mmime::other::*;
+use std::ptr;
 
 use crate::constants::*;
+use crate::contact::*;
 use crate::context::Context;
 use crate::dc_chat::*;
-use crate::dc_contact::*;
 use crate::dc_e2ee::*;
 use crate::dc_location::*;
 use crate::dc_msg::*;
@@ -293,7 +294,6 @@ pub unsafe fn dc_mimefactory_load_mdn(
     }
 
     let mut success = 0;
-    let mut contact = 0 as *mut dc_contact_t;
 
     (*factory).recipients_names = clist_new();
     (*factory).recipients_addr = clist_new();
@@ -305,24 +305,19 @@ pub unsafe fn dc_mimefactory_load_mdn(
         .unwrap_or_else(|| 1)
     {
         // MDNs not enabled - check this is late, in the job. the use may have changed its choice while offline ...
-        contact = dc_contact_new((*factory).context);
-        if !(!dc_msg_load_from_db((*factory).msg, (*factory).context, msg_id)
-            || !dc_contact_load_from_db(
-                contact,
-                &(*factory).context.sql,
-                (*(*factory).msg).from_id,
-            ))
-        {
-            if !(0 != (*contact).blocked || (*(*factory).msg).chat_id <= 9 as libc::c_uint) {
+        if !dc_msg_load_from_db((*factory).msg, (*factory).context, msg_id) {
+            return success;
+        }
+
+        if let Ok(contact) = Contact::load_from_db((*factory).context, (*(*factory).msg).from_id) {
+            if !(contact.is_blocked() || (*(*factory).msg).chat_id <= 9 as libc::c_uint) {
                 // Do not send MDNs trash etc.; chats.blocked is already checked by the caller in dc_markseen_msgs()
                 if !((*(*factory).msg).from_id <= 9 as libc::c_uint) {
                     clist_insert_after(
                         (*factory).recipients_names,
                         (*(*factory).recipients_names).last,
-                        (if !(*contact).authname.is_null()
-                            && 0 != *(*contact).authname.offset(0isize) as libc::c_int
-                        {
-                            dc_strdup((*contact).authname)
+                        (if !contact.get_authname().is_empty() {
+                            contact.get_authname().strdup()
                         } else {
                             0 as *mut libc::c_char
                         }) as *mut libc::c_void,
@@ -330,7 +325,7 @@ pub unsafe fn dc_mimefactory_load_mdn(
                     clist_insert_after(
                         (*factory).recipients_addr,
                         (*(*factory).recipients_addr).last,
-                        dc_strdup((*contact).addr) as *mut libc::c_void,
+                        contact.get_addr().strdup() as *mut libc::c_void,
                     );
                     load_from(factory);
                     (*factory).timestamp = dc_create_smeared_timestamp((*factory).context);
@@ -345,15 +340,13 @@ pub unsafe fn dc_mimefactory_load_mdn(
         }
     }
 
-    dc_contact_unref(contact);
-
     success
 }
 
 // TODO should return bool /rtn
 pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc::c_int {
     let subject: *mut mailimf_subject;
-    let mut current_block: u64;
+    let mut ok_to_continue = true;
     let imf_fields: *mut mailimf_fields;
     let mut message: *mut mailmime = 0 as *mut mailmime;
     let mut message_text: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -799,12 +792,17 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                 )
             }
 
-            let mut final_text: *const libc::c_char = 0 as *const libc::c_char;
-            if !placeholdertext.is_null() {
-                final_text = placeholdertext
-            } else if !(*msg).text.is_null() && 0 != *(*msg).text.offset(0isize) as libc::c_int {
-                final_text = (*msg).text
-            }
+            let final_text = {
+                if !placeholdertext.is_null() {
+                    to_string(placeholdertext)
+                } else if let Some(ref text) = (*msg).text {
+                    text.clone()
+                } else {
+                    "".into()
+                }
+            };
+            let final_text = CString::yolo(final_text);
+
             let footer: *mut libc::c_char = (*factory).selfstatus;
             message_text = dc_mprintf(
                 b"%s%s%s%s%s\x00" as *const u8 as *const libc::c_char,
@@ -813,12 +811,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                 } else {
                     b"\x00" as *const u8 as *const libc::c_char
                 },
-                if !final_text.is_null() {
-                    final_text
-                } else {
-                    b"\x00" as *const u8 as *const libc::c_char
-                },
-                if !final_text.is_null()
+                final_text.as_ptr(),
+                if final_text != CString::yolo("")
                     && !footer.is_null()
                     && 0 != *footer.offset(0isize) as libc::c_int
                 {
@@ -853,7 +847,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                     );
                     set_error(factory, error);
                     free(error as *mut libc::c_void);
-                    current_block = 11328123142868406523;
+                    ok_to_continue = false;
                 } else {
                     let file_part: *mut mailmime =
                         build_body_file(msg, 0 as *const libc::c_char, 0 as *mut *mut libc::c_char);
@@ -861,86 +855,73 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                         mailmime_smart_add_part(message, file_part);
                         parts += 1
                     }
-                    current_block = 13000670339742628194;
                 }
-            } else {
-                current_block = 13000670339742628194;
             }
-            match current_block {
-                11328123142868406523 => {}
-                _ => {
-                    if parts == 0 {
-                        set_error(
-                            factory,
-                            b"Empty message.\x00" as *const u8 as *const libc::c_char,
-                        );
-                        current_block = 11328123142868406523;
-                    } else {
-                        if !meta_part.is_null() {
-                            mailmime_smart_add_part(message, meta_part);
-                        }
-                        if (*msg).param.exists(Param::SetLatitude) {
-                            let latitude = (*msg)
-                                .param
-                                .get_float(Param::SetLatitude)
-                                .unwrap_or_default();
-                            let longitude = (*msg)
-                                .param
-                                .get_float(Param::SetLongitude)
-                                .unwrap_or_default();
-                            let kml_file =
-                                dc_get_message_kml((*msg).timestamp_sort, latitude, longitude);
-                            if !kml_file.is_null() {
-                                let content_type = mailmime_content_new_with_str(
-                                    b"application/vnd.google-earth.kml+xml\x00" as *const u8
-                                        as *const libc::c_char,
-                                );
-                                let mime_fields = mailmime_fields_new_filename(
-                                    MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
-                                    dc_strdup(
-                                        b"message.kml\x00" as *const u8 as *const libc::c_char,
-                                    ),
-                                    MAILMIME_MECHANISM_8BIT as libc::c_int,
-                                );
-                                let kml_mime_part = mailmime_new_empty(content_type, mime_fields);
-                                mailmime_set_body_text(kml_mime_part, kml_file, strlen(kml_file));
-
-                                mailmime_smart_add_part(message, kml_mime_part);
-                            }
-                        }
-
-                        if dc_is_sending_locations_to_chat((*msg).context, (*msg).chat_id) {
-                            let mut last_added_location_id: uint32_t = 0 as uint32_t;
-                            let kml_file: *mut libc::c_char = dc_get_location_kml(
-                                (*msg).context,
-                                (*msg).chat_id,
-                                &mut last_added_location_id,
+            if ok_to_continue {
+                if parts == 0 {
+                    set_error(
+                        factory,
+                        b"Empty message.\x00" as *const u8 as *const libc::c_char,
+                    );
+                    ok_to_continue = false;
+                } else {
+                    if !meta_part.is_null() {
+                        mailmime_smart_add_part(message, meta_part);
+                    }
+                    if (*msg).param.exists(Param::SetLatitude) {
+                        let latitude = (*msg)
+                            .param
+                            .get_float(Param::SetLatitude)
+                            .unwrap_or_default();
+                        let longitude = (*msg)
+                            .param
+                            .get_float(Param::SetLongitude)
+                            .unwrap_or_default();
+                        let kml_file =
+                            dc_get_message_kml((*msg).timestamp_sort, latitude, longitude);
+                        if !kml_file.is_null() {
+                            let content_type = mailmime_content_new_with_str(
+                                b"application/vnd.google-earth.kml+xml\x00" as *const u8
+                                    as *const libc::c_char,
                             );
-                            if !kml_file.is_null() {
-                                let content_type: *mut mailmime_content =
-                                    mailmime_content_new_with_str(
-                                        b"application/vnd.google-earth.kml+xml\x00" as *const u8
-                                            as *const libc::c_char,
-                                    );
-                                let mime_fields: *mut mailmime_fields =
-                                    mailmime_fields_new_filename(
-                                        MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
-                                        dc_strdup(
-                                            b"location.kml\x00" as *const u8 as *const libc::c_char,
-                                        ),
-                                        MAILMIME_MECHANISM_8BIT as libc::c_int,
-                                    );
-                                let kml_mime_part: *mut mailmime =
-                                    mailmime_new_empty(content_type, mime_fields);
-                                mailmime_set_body_text(kml_mime_part, kml_file, strlen(kml_file));
-                                mailmime_smart_add_part(message, kml_mime_part);
-                                if !(*msg).param.exists(Param::SetLatitude) {
-                                    // otherwise, the independent location is already filed
-                                    (*factory).out_last_added_location_id = last_added_location_id;
-                                }
+                            let mime_fields = mailmime_fields_new_filename(
+                                MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
+                                dc_strdup(b"message.kml\x00" as *const u8 as *const libc::c_char),
+                                MAILMIME_MECHANISM_8BIT as libc::c_int,
+                            );
+                            let kml_mime_part = mailmime_new_empty(content_type, mime_fields);
+                            mailmime_set_body_text(kml_mime_part, kml_file, strlen(kml_file));
+
+                            mailmime_smart_add_part(message, kml_mime_part);
+                        }
+                    }
+
+                    if dc_is_sending_locations_to_chat((*msg).context, (*msg).chat_id) {
+                        let mut last_added_location_id: uint32_t = 0 as uint32_t;
+                        let kml_file: *mut libc::c_char = dc_get_location_kml(
+                            (*msg).context,
+                            (*msg).chat_id,
+                            &mut last_added_location_id,
+                        );
+                        if !kml_file.is_null() {
+                            let content_type: *mut mailmime_content = mailmime_content_new_with_str(
+                                b"application/vnd.google-earth.kml+xml\x00" as *const u8
+                                    as *const libc::c_char,
+                            );
+                            let mime_fields: *mut mailmime_fields = mailmime_fields_new_filename(
+                                MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
+                                dc_strdup(b"location.kml\x00" as *const u8 as *const libc::c_char),
+                                MAILMIME_MECHANISM_8BIT as libc::c_int,
+                            );
+                            let kml_mime_part: *mut mailmime =
+                                mailmime_new_empty(content_type, mime_fields);
+                            mailmime_set_body_text(kml_mime_part, kml_file, strlen(kml_file));
+                            mailmime_smart_add_part(message, kml_mime_part);
+                            if !(*msg).param.exists(Param::SetLatitude) {
+                                // otherwise, the independent location is already filed
+                                (*factory).out_last_added_location_id = last_added_location_id;
                             }
                         }
-                        current_block = 9952640327414195044;
                     }
                 }
             }
@@ -994,86 +975,81 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
             mailmime_set_body_text(mach_mime_part, message_text2, strlen(message_text2));
             mailmime_add_part(multipart, mach_mime_part);
             force_plaintext = 2;
-            current_block = 9952640327414195044;
         } else {
             set_error(
                 factory,
                 b"No message loaded.\x00" as *const u8 as *const libc::c_char,
             );
-            current_block = 11328123142868406523;
+            ok_to_continue = false;
         }
 
-        match current_block {
-            11328123142868406523 => {}
-            _ => {
-                if (*factory).loaded as libc::c_uint
-                    == DC_MF_MDN_LOADED as libc::c_int as libc::c_uint
-                {
-                    let e = CString::new(
-                        (*factory)
-                            .context
-                            .stock_str(StockMessage::ReadRcpt)
-                            .as_ref(),
-                    )
-                    .unwrap();
-                    subject_str = dc_mprintf(
-                        b"Chat: %s\x00" as *const u8 as *const libc::c_char,
-                        e.as_ptr(),
-                    );
-                } else {
-                    subject_str = get_subject((*factory).chat, (*factory).msg, afwd_email)
-                }
-                subject = mailimf_subject_new(dc_encode_header_words(subject_str));
-                mailimf_fields_add(
-                    imf_fields,
-                    mailimf_field_new(
-                        MAILIMF_FIELD_SUBJECT as libc::c_int,
-                        0 as *mut mailimf_return,
-                        0 as *mut mailimf_orig_date,
-                        0 as *mut mailimf_from,
-                        0 as *mut mailimf_sender,
-                        0 as *mut mailimf_to,
-                        0 as *mut mailimf_cc,
-                        0 as *mut mailimf_bcc,
-                        0 as *mut mailimf_message_id,
-                        0 as *mut mailimf_orig_date,
-                        0 as *mut mailimf_from,
-                        0 as *mut mailimf_sender,
-                        0 as *mut mailimf_reply_to,
-                        0 as *mut mailimf_to,
-                        0 as *mut mailimf_cc,
-                        0 as *mut mailimf_bcc,
-                        0 as *mut mailimf_message_id,
-                        0 as *mut mailimf_in_reply_to,
-                        0 as *mut mailimf_references,
-                        subject,
-                        0 as *mut mailimf_comments,
-                        0 as *mut mailimf_keywords,
-                        0 as *mut mailimf_optional_field,
-                    ),
+        if ok_to_continue {
+            if (*factory).loaded as libc::c_uint == DC_MF_MDN_LOADED as libc::c_int as libc::c_uint
+            {
+                let e = CString::new(
+                    (*factory)
+                        .context
+                        .stock_str(StockMessage::ReadRcpt)
+                        .as_ref(),
+                )
+                .unwrap();
+                subject_str = dc_mprintf(
+                    b"Chat: %s\x00" as *const u8 as *const libc::c_char,
+                    e.as_ptr(),
                 );
-                if force_plaintext != 2 {
-                    dc_e2ee_encrypt(
-                        (*factory).context,
-                        (*factory).recipients_addr,
-                        force_plaintext,
-                        e2ee_guaranteed,
-                        min_verified,
-                        do_gossip,
-                        message,
-                        &mut e2ee_helper,
-                    );
-                }
-                if 0 != e2ee_helper.encryption_successfull {
-                    (*factory).out_encrypted = 1;
-                    if 0 != do_gossip {
-                        (*factory).out_gossiped = 1
-                    }
-                }
-                (*factory).out = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
-                mailmime_write_mem((*factory).out, &mut col, message);
-                success = 1
+            } else {
+                subject_str = get_subject((*factory).chat, (*factory).msg, afwd_email)
             }
+            subject = mailimf_subject_new(dc_encode_header_words(subject_str));
+            mailimf_fields_add(
+                imf_fields,
+                mailimf_field_new(
+                    MAILIMF_FIELD_SUBJECT as libc::c_int,
+                    0 as *mut mailimf_return,
+                    0 as *mut mailimf_orig_date,
+                    0 as *mut mailimf_from,
+                    0 as *mut mailimf_sender,
+                    0 as *mut mailimf_to,
+                    0 as *mut mailimf_cc,
+                    0 as *mut mailimf_bcc,
+                    0 as *mut mailimf_message_id,
+                    0 as *mut mailimf_orig_date,
+                    0 as *mut mailimf_from,
+                    0 as *mut mailimf_sender,
+                    0 as *mut mailimf_reply_to,
+                    0 as *mut mailimf_to,
+                    0 as *mut mailimf_cc,
+                    0 as *mut mailimf_bcc,
+                    0 as *mut mailimf_message_id,
+                    0 as *mut mailimf_in_reply_to,
+                    0 as *mut mailimf_references,
+                    subject,
+                    0 as *mut mailimf_comments,
+                    0 as *mut mailimf_keywords,
+                    0 as *mut mailimf_optional_field,
+                ),
+            );
+            if force_plaintext != 2 {
+                dc_e2ee_encrypt(
+                    (*factory).context,
+                    (*factory).recipients_addr,
+                    force_plaintext,
+                    e2ee_guaranteed,
+                    min_verified,
+                    do_gossip,
+                    message,
+                    &mut e2ee_helper,
+                );
+            }
+            if 0 != e2ee_helper.encryption_successfull {
+                (*factory).out_encrypted = 1;
+                if 0 != do_gossip {
+                    (*factory).out_gossiped = 1
+                }
+            }
+            (*factory).out = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
+            mailmime_write_mem((*factory).out, &mut col, message);
+            success = 1
         }
     }
     if !message.is_null() {
@@ -1094,8 +1070,17 @@ unsafe fn get_subject(
 ) -> *mut libc::c_char {
     let context = (*chat).context;
     let ret: *mut libc::c_char;
-    let raw_subject =
-        dc_msg_get_summarytext_by_raw((*msg).type_0, (*msg).text, &mut (*msg).param, 32, context);
+
+    let raw_subject = {
+        let msgtext_c = (*msg)
+            .text
+            .as_ref()
+            .map(|s| CString::yolo(String::as_str(s)));
+        let msgtext_ptr = msgtext_c.map_or(ptr::null(), |s| s.as_ptr());
+
+        dc_msg_get_summarytext_by_raw((*msg).type_0, msgtext_ptr, &mut (*msg).param, 32, context)
+    };
+
     let fwd = if 0 != afwd_email {
         b"Fwd: \x00" as *const u8 as *const libc::c_char
     } else {
@@ -1326,16 +1311,14 @@ unsafe fn build_body_file(
 /*******************************************************************************
  * Render
  ******************************************************************************/
-#[allow(non_snake_case)]
 unsafe fn is_file_size_okay(msg: *const dc_msg_t) -> bool {
     let mut file_size_okay = true;
-    let pathNfilename = (*msg).param.get(Param::File).unwrap_or_default().strdup();
-    let bytes = dc_get_filebytes((*msg).context, pathNfilename);
+    let path = (*msg).param.get(Param::File).unwrap_or_default();
+    let bytes = dc_get_filebytes((*msg).context, &path);
 
     if bytes > (49 * 1024 * 1024 / 4 * 3) {
         file_size_okay = false;
     }
-    free(pathNfilename as *mut _);
 
     file_size_okay
 }

src/dc_mimeparser.rs

@@ -11,8 +11,8 @@ use mmime::mailmime_types::*;
 use mmime::mmapstring::*;
 use mmime::other::*;
 
+use crate::contact::*;
 use crate::context::Context;
-use crate::dc_contact::*;
 use crate::dc_e2ee::*;
 use crate::dc_location::*;
 use crate::dc_simplify::*;
@@ -98,34 +98,34 @@ pub unsafe fn dc_mimeparser_empty(mimeparser: &mut dc_mimeparser_t) {
         dc_mimepart_unref(part);
     }
     assert!(mimeparser.parts.is_empty());
-    (*mimeparser).header_root = 0 as *mut mailimf_fields;
-    (*mimeparser).header.clear();
-    if !(*mimeparser).header_protected.is_null() {
-        mailimf_fields_free((*mimeparser).header_protected);
-        (*mimeparser).header_protected = 0 as *mut mailimf_fields
+    mimeparser.header_root = 0 as *mut mailimf_fields;
+    mimeparser.header.clear();
+    if !mimeparser.header_protected.is_null() {
+        mailimf_fields_free(mimeparser.header_protected);
+        mimeparser.header_protected = 0 as *mut mailimf_fields
     }
-    (*mimeparser).is_send_by_messenger = 0i32;
-    (*mimeparser).is_system_message = 0i32;
-    free((*mimeparser).subject as *mut libc::c_void);
-    (*mimeparser).subject = 0 as *mut libc::c_char;
-    if !(*mimeparser).mimeroot.is_null() {
-        mailmime_free((*mimeparser).mimeroot);
-        (*mimeparser).mimeroot = 0 as *mut mailmime
+    mimeparser.is_send_by_messenger = 0i32;
+    mimeparser.is_system_message = 0i32;
+    free(mimeparser.subject as *mut libc::c_void);
+    mimeparser.subject = 0 as *mut libc::c_char;
+    if !mimeparser.mimeroot.is_null() {
+        mailmime_free(mimeparser.mimeroot);
+        mimeparser.mimeroot = 0 as *mut mailmime
     }
-    (*mimeparser).is_forwarded = 0i32;
-    (*mimeparser).reports.clear();
-    (*mimeparser).decrypting_failed = 0i32;
-    dc_e2ee_thanks(&mut (*mimeparser).e2ee_helper);
+    mimeparser.is_forwarded = 0i32;
+    mimeparser.reports.clear();
+    mimeparser.decrypting_failed = 0i32;
+    dc_e2ee_thanks(&mut mimeparser.e2ee_helper);
 
-    if let Some(location_kml) = (*mimeparser).location_kml.as_mut() {
+    if let Some(location_kml) = mimeparser.location_kml.as_mut() {
         dc_kml_unref(location_kml);
     }
-    (*mimeparser).location_kml = None;
+    mimeparser.location_kml = None;
 
-    if let Some(message_kml) = (*mimeparser).message_kml.as_mut() {
+    if let Some(message_kml) = mimeparser.message_kml.as_mut() {
         dc_kml_unref(message_kml);
     }
-    (*mimeparser).message_kml = None;
+    mimeparser.message_kml = None;
 }
 
 unsafe fn dc_mimepart_unref(mut mimepart: dc_mimepart_t) {
@@ -148,27 +148,21 @@ pub unsafe fn dc_mimeparser_parse(
         body_not_terminated,
         body_bytes,
         &mut index,
-        &mut (*mimeparser).mimeroot,
+        &mut mimeparser.mimeroot,
     );
-    if !(r != MAILIMF_NO_ERROR as libc::c_int || (*mimeparser).mimeroot.is_null()) {
+    if !(r != MAILIMF_NO_ERROR as libc::c_int || mimeparser.mimeroot.is_null()) {
         dc_e2ee_decrypt(
-            (*mimeparser).context,
-            (*mimeparser).mimeroot,
-            &mut (*mimeparser).e2ee_helper,
+            mimeparser.context,
+            mimeparser.mimeroot,
+            &mut mimeparser.e2ee_helper,
         );
-        dc_mimeparser_parse_mime_recursive(mimeparser, (*mimeparser).mimeroot);
+        dc_mimeparser_parse_mime_recursive(mimeparser, mimeparser.mimeroot);
         let field: *mut mailimf_field = dc_mimeparser_lookup_field(mimeparser, "Subject");
         if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
-            (*mimeparser).subject =
-                dc_decode_header_words((*(*field).fld_data.fld_subject).sbj_value)
+            mimeparser.subject = dc_decode_header_words((*(*field).fld_data.fld_subject).sbj_value)
         }
-        if !dc_mimeparser_lookup_optional_field(
-            mimeparser,
-            b"Chat-Version\x00" as *const u8 as *const libc::c_char,
-        )
-        .is_null()
-        {
-            (*mimeparser).is_send_by_messenger = 1i32
+        if !dc_mimeparser_lookup_optional_field(mimeparser, "Chat-Version").is_null() {
+            mimeparser.is_send_by_messenger = 1i32
         }
         if !dc_mimeparser_lookup_field(mimeparser, "Autocrypt-Setup-Message").is_null() {
             let mut has_setup_file: libc::c_int = 0i32;
@@ -202,17 +196,14 @@ pub unsafe fn dc_mimeparser_parse(
                 }
             }
         } else {
-            optional_field = dc_mimeparser_lookup_optional_field(
-                mimeparser,
-                b"Chat-Content\x00" as *const u8 as *const libc::c_char,
-            );
+            optional_field = dc_mimeparser_lookup_optional_field(mimeparser, "Chat-Content");
             if !optional_field.is_null() && !(*optional_field).fld_value.is_null() {
                 if strcmp(
                     (*optional_field).fld_value,
                     b"location-streaming-enabled\x00" as *const u8 as *const libc::c_char,
                 ) == 0i32
                 {
-                    (*mimeparser).is_system_message = 8i32
+                    mimeparser.is_system_message = 8i32
                 }
             }
         }
@@ -229,7 +220,7 @@ pub unsafe fn dc_mimeparser_parse(
                 }
             }
         }
-        if 0 != (*mimeparser).is_send_by_messenger
+        if 0 != mimeparser.is_send_by_messenger
             && 0 != S_GENERATE_COMPOUND_MSGS
             && mimeparser.parts.len() == 2
         {
@@ -248,22 +239,33 @@ pub unsafe fn dc_mimeparser_parse(
             }
 
             if need_drop {
-                free(mimeparser.parts[1].msg as *mut libc::c_void);
-                let mut textpart = mimeparser.parts.swap_remove(0);
-                mimeparser.parts[1].msg = textpart.msg;
-                textpart.msg = 0 as *mut libc::c_char;
-                dc_mimepart_unref(textpart);
+                let mut filepart = mimeparser.parts.swap_remove(1);
+
+                // clear old one
+                free(filepart.msg as *mut libc::c_void);
+
+                // insert new one
+                filepart.msg = mimeparser.parts[0].msg;
+
+                // forget the one we use now
+                mimeparser.parts[0].msg = std::ptr::null_mut();
+
+                // swap new with old
+                let old = std::mem::replace(&mut mimeparser.parts[0], filepart);
+
+                // unref old one
+                dc_mimepart_unref(old);
             }
         }
-        if !(*mimeparser).subject.is_null() {
+        if !mimeparser.subject.is_null() {
             let mut prepend_subject: libc::c_int = 1i32;
-            if 0 == (*mimeparser).decrypting_failed {
-                let p: *mut libc::c_char = strchr((*mimeparser).subject, ':' as i32);
-                if p.wrapping_offset_from((*mimeparser).subject) == 2
-                    || p.wrapping_offset_from((*mimeparser).subject) == 3
-                    || 0 != (*mimeparser).is_send_by_messenger
+            if 0 == mimeparser.decrypting_failed {
+                let p: *mut libc::c_char = strchr(mimeparser.subject, ':' as i32);
+                if p.wrapping_offset_from(mimeparser.subject) == 2
+                    || p.wrapping_offset_from(mimeparser.subject) == 3
+                    || 0 != mimeparser.is_send_by_messenger
                     || !strstr(
-                        (*mimeparser).subject,
+                        mimeparser.subject,
                         b"Chat:\x00" as *const u8 as *const libc::c_char,
                     )
                     .is_null()
@@ -272,7 +274,7 @@ pub unsafe fn dc_mimeparser_parse(
                 }
             }
             if 0 != prepend_subject {
-                let subj: *mut libc::c_char = dc_strdup((*mimeparser).subject);
+                let subj: *mut libc::c_char = dc_strdup(mimeparser.subject);
                 let p_0: *mut libc::c_char = strchr(subj, '[' as i32);
                 if !p_0.is_null() {
                     *p_0 = 0i32 as libc::c_char
@@ -295,18 +297,14 @@ pub unsafe fn dc_mimeparser_parse(
                 free(subj as *mut libc::c_void);
             }
         }
-        if 0 != (*mimeparser).is_forwarded {
+        if 0 != mimeparser.is_forwarded {
             for part in mimeparser.parts.iter_mut() {
                 part.param.set_int(Param::Forwarded, 1);
             }
         }
         if mimeparser.parts.len() == 1 {
             if mimeparser.parts[0].type_0 == 40i32 {
-                if !dc_mimeparser_lookup_optional_field(
-                    mimeparser,
-                    b"Chat-Voice-Message\x00" as *const u8 as *const libc::c_char,
-                )
-                .is_null()
+                if !dc_mimeparser_lookup_optional_field(mimeparser, "Chat-Voice-Message").is_null()
                 {
                     let part_mut = &mut mimeparser.parts[0];
                     part_mut.type_0 = 41i32
@@ -314,10 +312,7 @@ pub unsafe fn dc_mimeparser_parse(
             }
             let part = &mimeparser.parts[0];
             if part.type_0 == 40i32 || part.type_0 == 41i32 || part.type_0 == 50i32 {
-                let field_0 = dc_mimeparser_lookup_optional_field(
-                    mimeparser,
-                    b"Chat-Duration\x00" as *const u8 as *const libc::c_char,
-                );
+                let field_0 = dc_mimeparser_lookup_optional_field(mimeparser, "Chat-Duration");
                 if !field_0.is_null() {
                     let duration_ms: libc::c_int = dc_atoi_null_is_0((*field_0).fld_value);
                     if duration_ms > 0i32 && duration_ms < 24i32 * 60i32 * 60i32 * 1000i32 {
@@ -327,11 +322,9 @@ pub unsafe fn dc_mimeparser_parse(
                 }
             }
         }
-        if 0 == (*mimeparser).decrypting_failed {
-            let dn_field: *const mailimf_optional_field = dc_mimeparser_lookup_optional_field(
-                mimeparser,
-                b"Chat-Disposition-Notification-To\x00" as *const u8 as *const libc::c_char,
-            );
+        if 0 == mimeparser.decrypting_failed {
+            let dn_field: *const mailimf_optional_field =
+                dc_mimeparser_lookup_optional_field(mimeparser, "Chat-Disposition-Notification-To");
             if !dn_field.is_null() && dc_mimeparser_get_last_nonmeta(mimeparser).is_some() {
                 let mut mb_list: *mut mailimf_mailbox_list = 0 as *mut mailimf_mailbox_list;
                 let mut index_0: size_t = 0i32 as size_t;
@@ -372,11 +365,11 @@ pub unsafe fn dc_mimeparser_parse(
         }
     }
     /* Cleanup - and try to create at least an empty part if there are no parts yet */
-    if dc_mimeparser_get_last_nonmeta(mimeparser).is_none() && (*mimeparser).reports.is_empty() {
+    if dc_mimeparser_get_last_nonmeta(mimeparser).is_none() && mimeparser.reports.is_empty() {
         let mut part_5 = dc_mimepart_new();
         part_5.type_0 = 10i32;
-        if !(*mimeparser).subject.is_null() && 0 == (*mimeparser).is_send_by_messenger {
-            part_5.msg = dc_strdup((*mimeparser).subject)
+        if !mimeparser.subject.is_null() && 0 == mimeparser.is_send_by_messenger {
+            part_5.msg = dc_strdup(mimeparser.subject)
         } else {
             part_5.msg = dc_strdup(b"\x00" as *const u8 as *const libc::c_char)
         }
@@ -422,7 +415,7 @@ pub unsafe fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> *
             0 as *mut libc::c_void
         }) as *mut mailimf_mailbox;
         if !mb.is_null() && !(*mb).mb_addr_spec.is_null() {
-            return dc_addr_normalize((*mb).mb_addr_spec);
+            return addr_normalize(as_str((*mb).mb_addr_spec)).strdup();
         }
         cur = if !cur.is_null() {
             (*cur).next
@@ -449,11 +442,11 @@ pub fn dc_mimeparser_lookup_field(
 
 pub unsafe fn dc_mimeparser_lookup_optional_field(
     mimeparser: &dc_mimeparser_t,
-    field_name: *const libc::c_char,
+    field_name: &str,
 ) -> *mut mailimf_optional_field {
     let field = mimeparser
         .header
-        .get(as_str(field_name))
+        .get(field_name)
         .map(|v| *v)
         .unwrap_or_else(|| std::ptr::null_mut());
     if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
@@ -493,32 +486,32 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
             ) == 0i32
         {
             info!(
-                (*mimeparser).context,
+                mimeparser.context,
                 0, "Protected headers found in text/rfc822-headers attachment: Will be ignored.",
             );
             return 0i32;
         }
-        if (*mimeparser).header_protected.is_null() {
+        if mimeparser.header_protected.is_null() {
             let mut dummy: size_t = 0i32 as size_t;
             if mailimf_envelope_and_optional_fields_parse(
                 (*mime).mm_mime_start,
                 (*mime).mm_length,
                 &mut dummy,
-                &mut (*mimeparser).header_protected,
+                &mut mimeparser.header_protected,
             ) != MAILIMF_NO_ERROR as libc::c_int
-                || (*mimeparser).header_protected.is_null()
+                || mimeparser.header_protected.is_null()
             {
-                warn!((*mimeparser).context, 0, "Protected headers parsing error.",);
+                warn!(mimeparser.context, 0, "Protected headers parsing error.",);
             } else {
                 hash_header(
-                    &mut (*mimeparser).header,
-                    (*mimeparser).header_protected,
-                    (*mimeparser).context,
+                    &mut mimeparser.header,
+                    mimeparser.header_protected,
+                    mimeparser.context,
                 );
             }
         } else {
             info!(
-                (*mimeparser).context,
+                mimeparser.context,
                 0,
                 "Protected headers found in MIME header: Will be ignored as we already found an outer one."
             );
@@ -622,7 +615,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                     let mut part = dc_mimepart_new();
                     part.type_0 = 10i32;
                     let msg_body = CString::new(
-                        (*mimeparser)
+                        mimeparser
                             .context
                             .stock_str(StockMessage::CantDecryptMsgBody)
                             .as_ref(),
@@ -635,7 +628,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                     part.msg_raw = dc_strdup(part.msg);
                     mimeparser.parts.push(part);
                     any_part_added = 1i32;
-                    (*mimeparser).decrypting_failed = 1i32
+                    mimeparser.decrypting_failed = 1i32
                 }
                 46 => {
                     cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
@@ -663,7 +656,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                                 b"disposition-notification\x00" as *const u8 as *const libc::c_char,
                             ) == 0i32
                         {
-                            (*mimeparser).reports.push(mime);
+                            mimeparser.reports.push(mime);
                         } else {
                             any_part_added = dc_mimeparser_parse_mime_recursive(
                                 mimeparser,
@@ -713,7 +706,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                     }
                     if plain_cnt == 1i32 && html_cnt == 1i32 {
                         warn!(
-                            (*mimeparser).context,
+                            mimeparser.context,
                             0i32,
                             "HACK: multipart/mixed message found with PLAIN and HTML, we\'ll skip the HTML part as this seems to be unwanted."
                         );
@@ -742,12 +735,12 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
             }
         }
         3 => {
-            if (*mimeparser).header_root.is_null() {
-                (*mimeparser).header_root = (*mime).mm_data.mm_message.mm_fields;
+            if mimeparser.header_root.is_null() {
+                mimeparser.header_root = (*mime).mm_data.mm_message.mm_fields;
                 hash_header(
-                    &mut (*mimeparser).header,
-                    (*mimeparser).header_root,
-                    (*mimeparser).context,
+                    &mut mimeparser.header,
+                    mimeparser.header_root,
+                    mimeparser.context,
                 );
             }
             if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
@@ -1102,7 +1095,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
     /* must not be free()'d */
     let mut decoded_data: *const libc::c_char = 0 as *const libc::c_char;
     let mut decoded_data_bytes = 0;
-    let mut simplifier: Option<dc_simplify_t> = None;
+    let mut simplifier: Option<Simplify> = None;
     if !(mime.is_null() || (*mime).mm_data.mm_single.is_null()) {
         mime_type = mailmime_get_mime_type(mime, &mut msg_type, &mut raw_mime);
         mime_data = (*mime).mm_data.mm_single;
@@ -1124,11 +1117,10 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                 match mime_type {
                     60 | 70 => {
                         if simplifier.is_none() {
-                            simplifier = Some(dc_simplify_t::new());
+                            simplifier = Some(Simplify::new());
                         }
                         /* get from `Content-Type: text/...; charset=utf-8`; must not be free()'d */
-                        let charset: *const libc::c_char =
-                            mailmime_content_charset_get((*mime).mm_content_type);
+                        let charset = mailmime_content_charset_get((*mime).mm_content_type);
                         if !charset.is_null()
                             && strcmp(charset, b"utf-8\x00" as *const u8 as *const libc::c_char)
                                 != 0i32
@@ -1144,12 +1136,16 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                 );
 
                                 let (res, _, _) = encoding.decode(data);
+                                info!(mimeparser.context, 0, "decoded message: '{}'", res);
                                 if res.is_empty() {
                                     /* no error - but nothing to add */
                                     current_block = 8795901732489102124;
                                 } else {
-                                    decoded_data_bytes = res.len();
-                                    decoded_data = res.as_ptr() as *const libc::c_char;
+                                    let b = res.as_bytes();
+                                    decoded_data = b.as_ptr() as *const libc::c_char;
+                                    decoded_data_bytes = b.len();
+                                    std::mem::forget(res);
+
                                     current_block = 17788412896529399552;
                                 }
                             } else {
@@ -1169,19 +1165,19 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                             8795901732489102124 => {}
                             _ => {
                                 /* check header directly as is_send_by_messenger is not yet set up */
-                                let is_msgrmsg: libc::c_int = (dc_mimeparser_lookup_optional_field(
+                                let is_msgrmsg = (!dc_mimeparser_lookup_optional_field(
                                     &mimeparser,
-                                    b"Chat-Version\x00" as *const u8 as *const libc::c_char,
-                                ) != 0 as *mut libc::c_void
-                                    as *mut mailimf_optional_field)
+                                    "Chat-Version",
+                                )
+                                .is_null())
                                     as libc::c_int;
-                                let simplified_txt: *mut libc::c_char =
-                                    simplifier.unwrap().simplify(
-                                        decoded_data,
-                                        decoded_data_bytes as libc::c_int,
-                                        if mime_type == 70i32 { 1i32 } else { 0i32 },
-                                        is_msgrmsg,
-                                    );
+
+                                let simplified_txt = simplifier.unwrap().simplify(
+                                    decoded_data,
+                                    decoded_data_bytes as libc::c_int,
+                                    mime_type == 70i32,
+                                    is_msgrmsg,
+                                );
                                 if !simplified_txt.is_null()
                                     && 0 != *simplified_txt.offset(0isize) as libc::c_int
                                 {
@@ -1195,8 +1191,8 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                 } else {
                                     free(simplified_txt as *mut libc::c_void);
                                 }
-                                if 0 != simplifier.unwrap().is_forwarded {
-                                    (*mimeparser).is_forwarded = 1i32
+                                if simplifier.unwrap().is_forwarded {
+                                    mimeparser.is_forwarded = 1i32
                                 }
                                 current_block = 10261677128829721533;
                             }
@@ -1324,8 +1320,8 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                         4,
                                     ) == 0i32
                                 {
-                                    (*mimeparser).location_kml = Some(dc_kml_parse(
-                                        (*mimeparser).context,
+                                    mimeparser.location_kml = Some(dc_kml_parse(
+                                        mimeparser.context,
                                         decoded_data,
                                         decoded_data_bytes,
                                     ));
@@ -1343,8 +1339,8 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                         4,
                                     ) == 0i32
                                 {
-                                    (*mimeparser).message_kml = Some(dc_kml_parse(
-                                        (*mimeparser).context,
+                                    mimeparser.message_kml = Some(dc_kml_parse(
+                                        mimeparser.context,
                                         decoded_data,
                                         decoded_data_bytes,
                                     ));
@@ -1539,10 +1535,8 @@ pub unsafe fn dc_mimeparser_is_mailinglist_message(mimeparser: &dc_mimeparser_t)
     if !dc_mimeparser_lookup_field(&mimeparser, "List-Id").is_null() {
         return 1i32;
     }
-    let precedence: *mut mailimf_optional_field = dc_mimeparser_lookup_optional_field(
-        mimeparser,
-        b"Precedence\x00" as *const u8 as *const libc::c_char,
-    );
+    let precedence: *mut mailimf_optional_field =
+        dc_mimeparser_lookup_optional_field(mimeparser, "Precedence");
     if !precedence.is_null() {
         if strcasecmp(
             (*precedence).fld_value,
@@ -1565,8 +1559,8 @@ pub unsafe fn dc_mimeparser_sender_equals_recipient(mimeparser: &dc_mimeparser_t
     let fld: *const mailimf_field;
     let mut fld_from: *const mailimf_from = 0 as *const mailimf_from;
     let mb: *mut mailimf_mailbox;
-    let mut from_addr_norm: *mut libc::c_char = 0 as *mut libc::c_char;
-    if !(*mimeparser).header_root.is_null() {
+
+    if !mimeparser.header_root.is_null() {
         /* get From: and check there is exactly one sender */
         fld = mailimf_find_field(mimeparser.header_root, MAILIMF_FIELD_FROM as libc::c_int);
         if !(fld.is_null()
@@ -1584,17 +1578,16 @@ pub unsafe fn dc_mimeparser_sender_equals_recipient(mimeparser: &dc_mimeparser_t
                 0 as *mut libc::c_void
             }) as *mut mailimf_mailbox;
             if !mb.is_null() {
-                from_addr_norm = dc_addr_normalize((*mb).mb_addr_spec);
+                let from_addr_norm = addr_normalize(as_str((*mb).mb_addr_spec));
                 let recipients = mailimf_get_recipients(mimeparser.header_root);
                 if recipients.len() == 1 {
-                    if recipients.contains(as_str(from_addr_norm)) {
+                    if recipients.contains(from_addr_norm) {
                         sender_equals_recipient = 1i32;
                     }
                 }
             }
         }
     }
-    free(from_addr_norm as *mut libc::c_void);
 
     sender_equals_recipient
 }
@@ -1691,15 +1684,15 @@ pub unsafe fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<
 /* ******************************************************************************
  * low-level-tools for getting a list of all recipients
  ******************************************************************************/
+
 #[allow(non_snake_case)]
 unsafe fn mailimf_get_recipients__add_addr(
     recipients: &mut HashSet<String>,
     mb: *mut mailimf_mailbox,
 ) {
     if !mb.is_null() {
-        let addr_norm: *mut libc::c_char = dc_addr_normalize((*mb).mb_addr_spec);
-        recipients.insert(to_string(addr_norm));
-        free(addr_norm as *mut libc::c_void);
+        let addr_norm = addr_normalize(as_str((*mb).mb_addr_spec));
+        recipients.insert(addr_norm.into());
     };
 }
 

src/dc_move.rs

@@ -27,13 +27,13 @@ pub unsafe fn dc_do_heuristics_moves(context: &Context, folder: &str, msg_id: u3
     }
 
     if dc_is_mvbox(context, folder) {
-        dc_update_msg_move_state(context, (*msg).rfc724_mid, DC_MOVE_STATE_STAY);
+        dc_update_msg_move_state(context, (*msg).rfc724_mid, MoveState::Stay);
     }
 
     // 1 = dc message, 2 = reply to dc message
     if 0 != (*msg).is_dc_message {
         dc_job_add(context, 200, (*msg).id as libc::c_int, Params::new(), 0);
-        dc_update_msg_move_state(context, (*msg).rfc724_mid, DC_MOVE_STATE_MOVING);
+        dc_update_msg_move_state(context, (*msg).rfc724_mid, MoveState::Moving);
     }
 
     dc_msg_unref(msg);

src/dc_msg.rs

@@ -1,9 +1,9 @@
 use std::ffi::CString;
 
 use crate::constants::*;
+use crate::contact::*;
 use crate::context::*;
 use crate::dc_chat::*;
-use crate::dc_contact::*;
 use crate::dc_job::*;
 use crate::dc_lot::dc_lot_t;
 use crate::dc_lot::*;
@@ -14,28 +14,28 @@ use crate::sql;
 use crate::stock::StockMessage;
 use crate::types::*;
 use crate::x::*;
+use std::ptr;
 
 /* * the structure behind dc_msg_t */
 #[derive(Clone)]
 #[repr(C)]
 pub struct dc_msg_t<'a> {
-    pub magic: uint32_t,
     pub id: uint32_t,
     pub from_id: uint32_t,
     pub to_id: uint32_t,
     pub chat_id: uint32_t,
-    pub move_state: dc_move_state_t,
+    pub move_state: MoveState,
     pub type_0: Viewtype,
     pub state: libc::c_int,
     pub hidden: libc::c_int,
     pub timestamp_sort: i64,
     pub timestamp_sent: i64,
     pub timestamp_rcvd: i64,
-    pub text: *mut libc::c_char,
+    pub text: Option<String>,
     pub context: &'a Context,
     pub rfc724_mid: *mut libc::c_char,
     pub in_reply_to: *mut libc::c_char,
-    pub server_folder: *mut libc::c_char,
+    pub server_folder: Option<String>,
     pub server_uid: uint32_t,
     pub is_dc_message: libc::c_int,
     pub starred: libc::c_int,
@@ -47,12 +47,10 @@ pub struct dc_msg_t<'a> {
 // handle messages
 pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_char {
     let msg = dc_msg_new_untyped(context);
-    let contact_from = dc_contact_new(context);
     let mut p: *mut libc::c_char;
     let mut ret = String::new();
 
     dc_msg_load_from_db(msg, context, msg_id);
-    dc_contact_load_from_db(contact_from, &context.sql, (*msg).from_id);
 
     let rawtxt: Option<String> = context.sql.query_row_col(
         context,
@@ -64,7 +62,6 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
     if rawtxt.is_none() {
         ret += &format!("Cannot load message #{}.", msg_id as usize);
         dc_msg_unref(msg);
-        dc_contact_unref(contact_from);
         return ret.strdup();
     }
     let rawtxt = rawtxt.unwrap();
@@ -73,12 +70,14 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
     let fts = dc_timestamp_to_str(dc_msg_get_timestamp(msg));
     ret += &format!("Sent: {}", fts);
 
-    p = dc_contact_get_name_n_addr(contact_from);
-    ret += &format!(" by {}", to_string(p));
-    free(p as *mut libc::c_void);
+    let name = Contact::load_from_db(context, (*msg).from_id)
+        .map(|contact| contact.get_name_n_addr())
+        .unwrap_or_default();
+
+    ret += &format!(" by {}", name);
     ret += "\n";
 
-    if (*msg).from_id != 1 as libc::c_uint {
+    if (*msg).from_id != DC_CONTACT_ID_SELF as libc::c_uint {
         let s = dc_timestamp_to_str(if 0 != (*msg).timestamp_rcvd {
             (*msg).timestamp_rcvd
         } else {
@@ -91,7 +90,6 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
     if (*msg).from_id == 2 || (*msg).to_id == 2 {
         // device-internal message, no further details needed
         dc_msg_unref(msg);
-        dc_contact_unref(contact_from);
         return ret.strdup();
     }
 
@@ -111,14 +109,11 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
                     let fts = dc_timestamp_to_str(ts);
                     ret += &format!("Read: {}", fts);
 
-                    let contact = dc_contact_new(context);
-                    dc_contact_load_from_db(contact, &context.sql, contact_id as u32);
-
-                    p = dc_contact_get_name_n_addr(contact);
-                    ret += &format!(" by {}", as_str(p));
-                    free(p as *mut libc::c_void);
-                    dc_contact_unref(contact);
+                    let name = Contact::load_from_db(context, contact_id as u32)
+                        .map(|contact| contact.get_name_n_addr())
+                        .unwrap_or_default();
 
+                    ret += &format!(" by {}", name);
                     ret += "\n";
                 }
                 Ok(())
@@ -172,7 +167,7 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
         ret += &format!(
             "\nFile: {}, {}, bytes\n",
             as_str(p),
-            dc_get_filebytes(context, p) as libc::c_int,
+            dc_get_filebytes(context, as_path(p)) as libc::c_int,
         );
     }
     free(p as *mut libc::c_void);
@@ -198,18 +193,15 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
         ret += &format!("\n{}\n", rawtxt);
     }
     if !(*msg).rfc724_mid.is_null() && 0 != *(*msg).rfc724_mid.offset(0) as libc::c_int {
-        ret += &format!("\nMessage-ID: {}", (*msg).rfc724_mid as libc::c_int);
+        ret += &format!("\nMessage-ID: {}", as_str((*msg).rfc724_mid));
     }
-    if !(*msg).server_folder.is_null() && 0 != *(*msg).server_folder.offset(0) as libc::c_int {
-        ret += &format!(
-            "\nLast seen as: {}/{}",
-            to_string((*msg).server_folder),
-            (*msg).server_uid as libc::c_int,
-        );
+    if let Some(ref server_folder) = (*msg).server_folder {
+        if server_folder != "" {
+            ret += &format!("\nLast seen as: {}/{}", server_folder, (*msg).server_uid);
+        }
     }
 
     dc_msg_unref(msg);
-    dc_contact_unref(contact_from);
     ret.strdup()
 }
 
@@ -229,23 +221,22 @@ pub unsafe fn dc_msg_new_untyped<'a>(context: &'a Context) -> *mut dc_msg_t<'a>
 // approx. max. length returned by dc_get_msg_info()
 pub unsafe fn dc_msg_new<'a>(context: &'a Context, viewtype: Viewtype) -> *mut dc_msg_t<'a> {
     let msg = dc_msg_t {
-        magic: 0x11561156,
         id: 0,
         from_id: 0,
         to_id: 0,
         chat_id: 0,
-        move_state: 0,
+        move_state: MoveState::Undefined,
         type_0: viewtype,
         state: 0,
         hidden: 0,
         timestamp_sort: 0,
         timestamp_sent: 0,
         timestamp_rcvd: 0,
-        text: std::ptr::null_mut(),
+        text: None,
         context,
         rfc724_mid: std::ptr::null_mut(),
         in_reply_to: std::ptr::null_mut(),
-        server_folder: std::ptr::null_mut(),
+        server_folder: None,
         server_uid: 0,
         is_dc_message: 0,
         starred: 0,
@@ -257,27 +248,22 @@ pub unsafe fn dc_msg_new<'a>(context: &'a Context, viewtype: Viewtype) -> *mut d
     Box::into_raw(Box::new(msg))
 }
 
-pub unsafe fn dc_msg_unref(mut msg: *mut dc_msg_t) {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+pub unsafe fn dc_msg_unref(msg: *mut dc_msg_t) {
+    if msg.is_null() {
         return;
     }
     dc_msg_empty(msg);
-    (*msg).magic = 0i32 as uint32_t;
     Box::from_raw(msg);
 }
 
 pub unsafe fn dc_msg_empty(mut msg: *mut dc_msg_t) {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return;
     }
-    free((*msg).text as *mut libc::c_void);
-    (*msg).text = 0 as *mut libc::c_char;
     free((*msg).rfc724_mid as *mut libc::c_void);
     (*msg).rfc724_mid = 0 as *mut libc::c_char;
     free((*msg).in_reply_to as *mut libc::c_void);
     (*msg).in_reply_to = 0 as *mut libc::c_char;
-    free((*msg).server_folder as *mut libc::c_void);
-    (*msg).server_folder = 0 as *mut libc::c_char;
     (*msg).param = Params::new();
     (*msg).hidden = 0i32;
 }
@@ -285,7 +271,7 @@ pub unsafe fn dc_msg_empty(mut msg: *mut dc_msg_t) {
 pub unsafe fn dc_msg_get_filemime(msg: *const dc_msg_t) -> *mut libc::c_char {
     let mut ret = 0 as *mut libc::c_char;
 
-    if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
+    if !msg.is_null() {
         match (*msg).param.get(Param::MimeType) {
             Some(m) => {
                 ret = m.strdup();
@@ -369,7 +355,7 @@ pub unsafe fn dc_msg_guess_msgtype_from_suffix(
 pub unsafe fn dc_msg_get_file(msg: *const dc_msg_t) -> *mut libc::c_char {
     let mut file_abs = 0 as *mut libc::c_char;
 
-    if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
+    if !msg.is_null() {
         if let Some(file_rel) = (*msg).param.get(Param::File) {
             let file_rel_c = CString::yolo(file_rel);
             file_abs = dc_get_abs_path((*msg).context, file_rel_c.as_ptr());
@@ -392,7 +378,7 @@ pub unsafe fn dc_msg_get_file(msg: *const dc_msg_t) -> *mut libc::c_char {
  * @return 1=Message has location bound to it, 0=No location bound to message.
  */
 pub unsafe fn dc_msg_has_location(msg: *const dc_msg_t) -> bool {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return false;
     }
 
@@ -421,10 +407,7 @@ pub unsafe fn dc_msg_set_location(
     latitude: libc::c_double,
     longitude: libc::c_double,
 ) {
-    if msg.is_null()
-        || (*msg).magic != 0x11561156i32 as libc::c_uint
-        || (latitude == 0.0 && longitude == 0.0)
-    {
+    if msg.is_null() || (latitude == 0.0 && longitude == 0.0) {
         return;
     }
 
@@ -433,7 +416,7 @@ pub unsafe fn dc_msg_set_location(
 }
 
 pub unsafe fn dc_msg_get_timestamp(msg: *const dc_msg_t) -> i64 {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
     return if 0 != (*msg).timestamp_sent {
@@ -467,7 +450,7 @@ pub fn dc_msg_load_from_db<'a>(msg: *mut dc_msg_t<'a>, context: &'a Context, id:
                     Some(s) => s.strdup(),
                     None => std::ptr::null_mut(),
                 };
-                (*msg).server_folder = row.get::<_, String>(3)?.strdup();
+                (*msg).server_folder = row.get::<_, Option<String>>(3)?;
                 (*msg).server_uid = row.get(4)?;
                 (*msg).move_state = row.get(5)?;
                 (*msg).chat_id = row.get(6)?;
@@ -479,21 +462,48 @@ pub fn dc_msg_load_from_db<'a>(msg: *mut dc_msg_t<'a>, context: &'a Context, id:
                 (*msg).type_0 = row.get(12)?;
                 (*msg).state = row.get(13)?;
                 (*msg).is_dc_message = row.get(14)?;
-                (*msg).text = row.get::<_, String>(15).unwrap_or_default().strdup();
+
+                let text;
+                if let rusqlite::types::ValueRef::Text(buf) = row.get_raw(15) {
+                    if let Ok(t) = String::from_utf8(buf.to_vec()) {
+                        text = t;
+                    } else {
+                        warn!(context, 0, "dc_msg_load_from_db: could not get text column as non-lossy utf8 id {}", id);
+                        text = String::from_utf8_lossy(buf).into_owned();
+                    }
+                } else {
+                    warn!(context, 0, "dc_msg_load_from_db: could not get text column for id {}", id);
+                    text = "[ Could not read from db ]".to_string();
+                }
+                (*msg).text = Some(text);
+
                 (*msg).param = row.get::<_, String>(16)?.parse().unwrap_or_default();
                 (*msg).starred = row.get(17)?;
                 (*msg).hidden = row.get(18)?;
                 (*msg).location_id = row.get(19)?;
                 (*msg).chat_blocked = row.get::<_, Option<i32>>(20)?.unwrap_or_default();
                 if (*msg).chat_blocked == 2 {
-                    dc_truncate_n_unwrap_str((*msg).text, 256, 0);
-                }
-            }
-            Ok(())
-        }
-    );
+                    if let Some(ref text) = (*msg).text {
+                        let ptr = text.strdup();
 
-    res.is_ok()
+                        dc_truncate_n_unwrap_str(ptr, 256, 0);
+
+                        (*msg).text = Some(to_string(ptr));
+                        free(ptr.cast());
+                    }
+                };
+                Ok(())
+            }
+        });
+
+    if let Err(e) = res {
+        warn!(
+            context,
+            0, "Error in msg_load_from_db for id {} because of {}", id, e
+        );
+        return false;
+    }
+    true
 }
 
 pub unsafe fn dc_get_mime_headers(context: &Context, msg_id: uint32_t) -> *mut libc::c_char {
@@ -629,12 +639,13 @@ pub fn dc_star_msgs(
 }
 
 pub unsafe fn dc_get_msg<'a>(context: &'a Context, msg_id: uint32_t) -> *mut dc_msg_t<'a> {
-    let mut success: libc::c_int = 0i32;
+    let mut success = false;
     let obj: *mut dc_msg_t = dc_msg_new_untyped(context);
     if dc_msg_load_from_db(obj, context, msg_id) {
-        success = 1i32
+        success = true
     }
-    if 0 != success {
+
+    if success {
         obj
     } else {
         dc_msg_unref(obj);
@@ -643,7 +654,7 @@ pub unsafe fn dc_get_msg<'a>(context: &'a Context, msg_id: uint32_t) -> *mut dc_
 }
 
 pub unsafe fn dc_msg_get_id(msg: *const dc_msg_t) -> uint32_t {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0i32 as uint32_t;
     }
 
@@ -651,7 +662,7 @@ pub unsafe fn dc_msg_get_id(msg: *const dc_msg_t) -> uint32_t {
 }
 
 pub unsafe fn dc_msg_get_from_id(msg: *const dc_msg_t) -> uint32_t {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0i32 as uint32_t;
     }
 
@@ -659,7 +670,7 @@ pub unsafe fn dc_msg_get_from_id(msg: *const dc_msg_t) -> uint32_t {
 }
 
 pub unsafe fn dc_msg_get_chat_id(msg: *const dc_msg_t) -> uint32_t {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0i32 as uint32_t;
     }
     return if 0 != (*msg).chat_blocked {
@@ -670,7 +681,7 @@ pub unsafe fn dc_msg_get_chat_id(msg: *const dc_msg_t) -> uint32_t {
 }
 
 pub unsafe fn dc_msg_get_viewtype(msg: *const dc_msg_t) -> Viewtype {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return Viewtype::Unknown;
     }
 
@@ -678,7 +689,7 @@ pub unsafe fn dc_msg_get_viewtype(msg: *const dc_msg_t) -> Viewtype {
 }
 
 pub unsafe fn dc_msg_get_state(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0i32;
     }
 
@@ -686,7 +697,7 @@ pub unsafe fn dc_msg_get_state(msg: *const dc_msg_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_msg_get_received_timestamp(msg: *const dc_msg_t) -> i64 {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
 
@@ -694,7 +705,7 @@ pub unsafe fn dc_msg_get_received_timestamp(msg: *const dc_msg_t) -> i64 {
 }
 
 pub unsafe fn dc_msg_get_sort_timestamp(msg: *const dc_msg_t) -> i64 {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
 
@@ -702,19 +713,21 @@ pub unsafe fn dc_msg_get_sort_timestamp(msg: *const dc_msg_t) -> i64 {
 }
 
 pub unsafe fn dc_msg_get_text(msg: *const dc_msg_t) -> *mut libc::c_char {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return dc_strdup(0 as *const libc::c_char);
     }
-
-    let res = dc_truncate_str(as_str((*msg).text), 30000);
-    res.strdup()
+    if let Some(ref text) = (*msg).text {
+        dc_truncate_str(text, 30000).strdup()
+    } else {
+        ptr::null_mut()
+    }
 }
 
 #[allow(non_snake_case)]
 pub unsafe fn dc_msg_get_filename(msg: *const dc_msg_t) -> *mut libc::c_char {
     let mut ret = 0 as *mut libc::c_char;
 
-    if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
+    if !msg.is_null() {
         if let Some(file) = (*msg).param.get(Param::File) {
             let file_c = CString::yolo(file);
             ret = dc_get_filename(file_c.as_ptr());
@@ -728,20 +741,17 @@ pub unsafe fn dc_msg_get_filename(msg: *const dc_msg_t) -> *mut libc::c_char {
 }
 
 pub unsafe fn dc_msg_get_filebytes(msg: *const dc_msg_t) -> uint64_t {
-    let mut ret = 0;
-
-    if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
+    if !msg.is_null() {
         if let Some(file) = (*msg).param.get(Param::File) {
-            let file_c = CString::yolo(file);
-            ret = dc_get_filebytes((*msg).context, file_c.as_ptr());
+            return dc_get_filebytes((*msg).context, &file);
         }
     }
 
-    ret
+    0
 }
 
 pub unsafe fn dc_msg_get_width(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
 
@@ -749,7 +759,7 @@ pub unsafe fn dc_msg_get_width(msg: *const dc_msg_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_msg_get_height(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
 
@@ -757,7 +767,7 @@ pub unsafe fn dc_msg_get_height(msg: *const dc_msg_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_msg_get_duration(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
 
@@ -766,7 +776,7 @@ pub unsafe fn dc_msg_get_duration(msg: *const dc_msg_t) -> libc::c_int {
 
 // TODO should return bool /rtn
 pub unsafe fn dc_msg_get_showpadlock(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
     if (*msg)
@@ -785,35 +795,32 @@ pub unsafe fn dc_msg_get_summary<'a>(
     msg: *mut dc_msg_t<'a>,
     mut chat: *const Chat<'a>,
 ) -> *mut dc_lot_t {
-    let current_block: u64;
+    let mut ok_to_continue = true;
     let ret: *mut dc_lot_t = dc_lot_new();
-    let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
     let mut chat_to_delete: *mut Chat = 0 as *mut Chat;
-    if !(msg.is_null() || (*msg).magic != 0x11561156 as libc::c_uint) {
+
+    if !msg.is_null() {
         if chat.is_null() {
             chat_to_delete = dc_get_chat((*msg).context, (*msg).chat_id);
             if chat_to_delete.is_null() {
-                current_block = 15204159476013091401;
+                ok_to_continue = false;
             } else {
                 chat = chat_to_delete;
-                current_block = 7815301370352969686;
             }
-        } else {
-            current_block = 7815301370352969686;
         }
-        match current_block {
-            15204159476013091401 => {}
-            _ => {
-                if (*msg).from_id != 1 as libc::c_uint
-                    && ((*chat).type_0 == 120 || (*chat).type_0 == 130)
-                {
-                    contact = dc_get_contact((*chat).context, (*msg).from_id)
-                }
-                dc_lot_fill(ret, msg, chat, contact, (*msg).context);
-            }
+        if ok_to_continue {
+            let contact = if (*msg).from_id != DC_CONTACT_ID_SELF as libc::c_uint
+                && ((*chat).type_0 == 120 || (*chat).type_0 == 130)
+            {
+                Contact::get_by_id((*chat).context, (*msg).from_id).ok()
+            } else {
+                None
+            };
+
+            dc_lot_fill(ret, msg, chat, contact.as_ref(), (*msg).context);
         }
     }
-    dc_contact_unref(contact);
+
     dc_chat_unref(chat_to_delete);
 
     ret
@@ -823,13 +830,19 @@ pub unsafe fn dc_msg_get_summarytext(
     msg: *mut dc_msg_t,
     approx_characters: libc::c_int,
 ) -> *mut libc::c_char {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return dc_strdup(0 as *const libc::c_char);
     }
 
+    let msgtext_c = (*msg)
+        .text
+        .as_ref()
+        .map(|s| CString::yolo(String::as_str(s)));
+    let msgtext_ptr = msgtext_c.map_or(ptr::null(), |s| s.as_ptr());
+
     dc_msg_get_summarytext_by_raw(
         (*msg).type_0,
-        (*msg).text,
+        msgtext_ptr,
         &mut (*msg).param,
         approx_characters,
         (*msg).context,
@@ -928,7 +941,7 @@ pub unsafe fn dc_msg_has_deviating_timestamp(msg: *const dc_msg_t) -> libc::c_in
 
 // TODO should return bool /rtn
 pub unsafe fn dc_msg_is_sent(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
     if (*msg).state >= DC_STATE_OUT_DELIVERED {
@@ -939,7 +952,7 @@ pub unsafe fn dc_msg_is_sent(msg: *const dc_msg_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_msg_is_starred(msg: *const dc_msg_t) -> bool {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return false;
     }
     0 != (*msg).starred
@@ -947,7 +960,7 @@ pub unsafe fn dc_msg_is_starred(msg: *const dc_msg_t) -> bool {
 
 // TODO should return bool /rtn
 pub unsafe fn dc_msg_is_forwarded(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
     if 0 != (*msg).param.get_int(Param::Forwarded).unwrap_or_default() {
@@ -959,7 +972,7 @@ pub unsafe fn dc_msg_is_forwarded(msg: *const dc_msg_t) -> libc::c_int {
 
 // TODO should return bool /rtn
 pub unsafe fn dc_msg_is_info(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
     let cmd = (*msg).param.get_int(Param::Cmd).unwrap_or_default();
@@ -975,7 +988,7 @@ pub unsafe fn dc_msg_is_info(msg: *const dc_msg_t) -> libc::c_int {
 
 // TODO should return bool /rtn
 pub unsafe fn dc_msg_is_increation(msg: *const dc_msg_t) -> libc::c_int {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return 0;
     }
 
@@ -987,10 +1000,7 @@ pub unsafe fn dc_msg_is_increation(msg: *const dc_msg_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_msg_is_setupmessage(msg: *const dc_msg_t) -> bool {
-    if msg.is_null()
-        || (*msg).magic != 0x11561156i32 as libc::c_uint
-        || (*msg).type_0 != Viewtype::File
-    {
+    if msg.is_null() || (*msg).type_0 != Viewtype::File {
         return false;
     }
 
@@ -1046,11 +1056,14 @@ pub unsafe fn dc_msg_get_setupcodebegin(msg: *const dc_msg_t) -> *mut libc::c_ch
 }
 
 pub unsafe fn dc_msg_set_text(mut msg: *mut dc_msg_t, text: *const libc::c_char) {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return;
     }
-    free((*msg).text as *mut libc::c_void);
-    (*msg).text = dc_strdup(text);
+    (*msg).text = if text.is_null() {
+        None
+    } else {
+        Some(to_string(text))
+    };
 }
 
 pub unsafe fn dc_msg_set_file(
@@ -1058,7 +1071,7 @@ pub unsafe fn dc_msg_set_file(
     file: *const libc::c_char,
     filemime: *const libc::c_char,
 ) {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return;
     }
     if !file.is_null() {
@@ -1070,7 +1083,7 @@ pub unsafe fn dc_msg_set_file(
 }
 
 pub unsafe fn dc_msg_set_dimension(msg: *mut dc_msg_t, width: libc::c_int, height: libc::c_int) {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return;
     }
     (*msg).param.set_int(Param::Width, width);
@@ -1078,7 +1091,7 @@ pub unsafe fn dc_msg_set_dimension(msg: *mut dc_msg_t, width: libc::c_int, heigh
 }
 
 pub unsafe fn dc_msg_set_duration(msg: *mut dc_msg_t, duration: libc::c_int) {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return;
     }
     (*msg).param.set_int(Param::Duration, duration);
@@ -1090,7 +1103,7 @@ pub unsafe fn dc_msg_latefiling_mediasize(
     height: libc::c_int,
     duration: libc::c_int,
 ) {
-    if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
+    if !msg.is_null() {
         if width > 0 && height > 0 {
             (*msg).param.set_int(Param::Width, width);
             (*msg).param.set_int(Param::Height, height);
@@ -1103,7 +1116,7 @@ pub unsafe fn dc_msg_latefiling_mediasize(
 }
 
 pub unsafe fn dc_msg_save_param_to_disk(msg: *mut dc_msg_t) -> bool {
-    if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
+    if msg.is_null() {
         return false;
     }
 
@@ -1174,7 +1187,7 @@ pub unsafe fn dc_msg_exists(context: &Context, msg_id: uint32_t) -> libc::c_int
 pub fn dc_update_msg_move_state(
     context: &Context,
     rfc724_mid: *const libc::c_char,
-    state: dc_move_state_t,
+    state: MoveState,
 ) -> bool {
     // we update the move_state for all messages belonging to a given Message-ID
     // so that the state stay intact when parts are deleted
@@ -1426,6 +1439,7 @@ pub fn dc_update_server_uid(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::test_utils as test;
     use std::ffi::CStr;
 
     #[test]
@@ -1546,4 +1560,32 @@ mod tests {
             free(mime_0 as *mut libc::c_void);
         }
     }
+
+    #[test]
+    pub fn test_prepare_message_and_send() {
+        use crate::config::Config;
+
+        unsafe {
+            let d = test::dummy_context();
+            let ctx = &d.ctx;
+
+            let contact =
+                Contact::create(ctx, "", "dest@example.com").expect("failed to create contact");
+
+            let res = ctx.set_config(Config::ConfiguredAddr, Some("self@example.com"));
+            assert!(res.is_ok());
+
+            let chat = dc_create_chat_by_contact_id(ctx, contact);
+            assert!(chat != 0);
+
+            let msg = dc_msg_new(ctx, Viewtype::Text);
+            assert!(!msg.is_null());
+
+            let msg_id = dc_prepare_msg(ctx, chat, msg);
+            assert!(msg_id != 0);
+
+            let msg2 = dc_get_msg(ctx, msg_id);
+            assert!(!msg2.is_null());
+        }
+    }
 }

src/dc_qr.rs

@@ -1,8 +1,8 @@
 use percent_encoding::percent_decode_str;
 
+use crate::contact::*;
 use crate::context::Context;
 use crate::dc_chat::*;
-use crate::dc_contact::*;
 use crate::dc_lot::*;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
@@ -66,8 +66,7 @@ pub unsafe fn dc_check_qr(context: &Context, qr: *const libc::c_char) -> *mut dc
                         let name_r = percent_decode_str(name_enc)
                             .decode_utf8()
                             .expect("invalid name");
-                        name = name_r.strdup();
-                        dc_normalize_name(name);
+                        name = normalize_name(name_r).strdup();
                     }
                     invitenumber = param
                         .get(Param::ProfileImage)
@@ -186,7 +185,7 @@ pub unsafe fn dc_check_qr(context: &Context, qr: *const libc::c_char) -> *mut dc
                                 b";\x00" as *const u8 as *const libc::c_char,
                                 b",\x00" as *const u8 as *const libc::c_char,
                             );
-                            dc_normalize_name(name);
+                            name = normalize_name(as_str(name)).strdup();
                         }
                     }
                 }
@@ -204,10 +203,10 @@ pub unsafe fn dc_check_qr(context: &Context, qr: *const libc::c_char) -> *mut dc
                     let mut temp: *mut libc::c_char = dc_urldecode(addr);
                     free(addr as *mut libc::c_void);
                     addr = temp;
-                    temp = dc_addr_normalize(addr);
+                    temp = addr_normalize(as_str(addr)).strdup();
                     free(addr as *mut libc::c_void);
                     addr = temp;
-                    if !dc_may_be_valid_addr(addr) {
+                    if !may_be_valid_addr(as_str(addr)) {
                         (*qr_parsed).state = 400i32;
                         (*qr_parsed).text1 = dc_strdup(
                             b"Bad e-mail address.\x00" as *const u8 as *const libc::c_char,
@@ -248,19 +247,19 @@ pub unsafe fn dc_check_qr(context: &Context, qr: *const libc::c_char) -> *mut dc
                                     if addr.is_null() || invitenumber.is_null() || auth.is_null() {
                                         if let Some(peerstate) = peerstate {
                                             (*qr_parsed).state = 210i32;
-                                            let addr_ptr = if let Some(ref addr) = peerstate.addr {
-                                                addr.strdup()
-                                            } else {
-                                                std::ptr::null()
-                                            };
-                                            (*qr_parsed).id = dc_add_or_lookup_contact(
+                                            let addr = peerstate
+                                                .addr
+                                                .as_ref()
+                                                .map(|s| s.as_str())
+                                                .unwrap_or_else(|| "");
+                                            (*qr_parsed).id = Contact::add_or_lookup(
                                                 context,
-                                                0 as *const libc::c_char,
-                                                addr_ptr,
-                                                0x80i32,
-                                                0 as *mut libc::c_int,
-                                            );
-                                            free(addr_ptr as *mut _);
+                                                "",
+                                                addr,
+                                                Origin::UnhandledQrScan,
+                                            )
+                                            .map(|(id, _)| id)
+                                            .unwrap_or_default();
                                             dc_create_or_lookup_nchat_by_contact_id(
                                                 context,
                                                 (*qr_parsed).id,
@@ -286,26 +285,28 @@ pub unsafe fn dc_check_qr(context: &Context, qr: *const libc::c_char) -> *mut dc
                                         } else {
                                             (*qr_parsed).state = 200i32
                                         }
-                                        (*qr_parsed).id = dc_add_or_lookup_contact(
+                                        (*qr_parsed).id = Contact::add_or_lookup(
                                             context,
-                                            name,
-                                            addr,
-                                            0x80i32,
-                                            0 as *mut libc::c_int,
-                                        );
+                                            as_str(name),
+                                            as_str(addr),
+                                            Origin::UnhandledQrScan,
+                                        )
+                                        .map(|(id, _)| id)
+                                        .unwrap_or_default();
                                         (*qr_parsed).fingerprint = dc_strdup(fingerprint);
                                         (*qr_parsed).invitenumber = dc_strdup(invitenumber);
                                         (*qr_parsed).auth = dc_strdup(auth)
                                     }
                                 } else if !addr.is_null() {
                                     (*qr_parsed).state = 320i32;
-                                    (*qr_parsed).id = dc_add_or_lookup_contact(
+                                    (*qr_parsed).id = Contact::add_or_lookup(
                                         context,
-                                        name,
-                                        addr,
-                                        0x80i32,
-                                        0 as *mut libc::c_int,
+                                        as_str(name),
+                                        as_str(addr),
+                                        Origin::UnhandledQrScan,
                                     )
+                                    .map(|(id, _)| id)
+                                    .unwrap_or_default();
                                 } else if strstr(
                                     qr,
                                     b"http://\x00" as *const u8 as *const libc::c_char,

src/dc_saxparser.rs

@@ -80,7 +80,7 @@ pub unsafe fn dc_saxparser_set_text_handler(
 }
 
 pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *const libc::c_char) {
-    let current_block: u64;
+    let mut is_valid = false;
     let mut bak: libc::c_char;
     let buf_start: *mut libc::c_char;
     let mut last_text_start: *mut libc::c_char;
@@ -99,7 +99,7 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
     p = buf_start;
     loop {
         if !(0 != *p) {
-            current_block = 13425230902034816933;
+            is_valid = true;
             break;
         }
         if *p as libc::c_int == '<' as i32 {
@@ -113,7 +113,6 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
             if strncmp(p, b"!--\x00" as *const u8 as *const libc::c_char, 3) == 0i32 {
                 p = strstr(p, b"-->\x00" as *const u8 as *const libc::c_char);
                 if p.is_null() {
-                    current_block = 7627180618761592946;
                     break;
                 }
                 p = p.offset(3isize)
@@ -137,7 +136,6 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
                         strlen(text_beg),
                         'c' as i32 as libc::c_char,
                     );
-                    current_block = 7627180618761592946;
                     break;
                 }
             } else if strncmp(p, b"!DOCTYPE\x00" as *const u8 as *const libc::c_char, 8) == 0i32 {
@@ -149,13 +147,11 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
                 }
                 if *p as libc::c_int == 0i32 {
                     /* unclosed doctype */
-                    current_block = 7627180618761592946;
                     break;
                 } else if *p as libc::c_int == '[' as i32 {
                     p = strstr(p, b"]>\x00" as *const u8 as *const libc::c_char);
                     if p.is_null() {
                         /* unclosed inline doctype */
-                        current_block = 7627180618761592946;
                         break;
                     } else {
                         p = p.offset(2isize)
@@ -167,7 +163,6 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
                 p = strstr(p, b"?>\x00" as *const u8 as *const libc::c_char);
                 if p.is_null() {
                     /* unclosed processing instruction */
-                    current_block = 7627180618761592946;
                     break;
                 } else {
                     p = p.offset(2isize)
@@ -328,7 +323,6 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
                 p = strchr(p, '>' as i32);
                 if p.is_null() {
                     /* unclosed start-tag or end-tag */
-                    current_block = 7627180618761592946;
                     break;
                 } else {
                     p = p.offset(1isize)
@@ -339,16 +333,13 @@ pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *c
             p = p.offset(1isize)
         }
     }
-    match current_block {
-        13425230902034816933 => {
-            call_text_cb(
-                saxparser,
-                last_text_start,
-                p.wrapping_offset_from(last_text_start) as size_t,
-                '&' as i32 as libc::c_char,
-            );
-        }
-        _ => {}
+    if is_valid {
+        call_text_cb(
+            saxparser,
+            last_text_start,
+            p.wrapping_offset_from(last_text_start) as size_t,
+            '&' as i32 as libc::c_char,
+        );
     }
     do_free_attr(attr.as_mut_ptr(), free_attr.as_mut_ptr());
     free(buf_start as *mut libc::c_void);

src/dc_securejoin.rs

@@ -5,11 +5,10 @@ use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 
 use crate::aheader::EncryptPreference;
 use crate::constants::*;
+use crate::contact::*;
 use crate::context::Context;
-use crate::dc_array::*;
 use crate::dc_chat::*;
 use crate::dc_configure::*;
-use crate::dc_contact::*;
 use crate::dc_e2ee::*;
 use crate::dc_lot::*;
 use crate::dc_mimeparser::*;
@@ -42,7 +41,7 @@ pub unsafe fn dc_get_securejoin_qr(
     let mut group_name_urlencoded = 0 as *mut libc::c_char;
     let mut qr: Option<String> = None;
 
-    dc_ensure_secret_key_exists(context);
+    dc_ensure_secret_key_exists(context).ok();
     invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id);
     if invitenumber.is_null() {
         invitenumber = dc_create_id().strdup();
@@ -149,7 +148,7 @@ pub unsafe fn dc_join_securejoin(context: &Context, qr: *const libc::c_char) ->
     let mut join_vg: libc::c_int = 0i32;
     let mut qr_scan: *mut dc_lot_t = 0 as *mut dc_lot_t;
     info!(context, 0, "Requesting secure-join ...",);
-    dc_ensure_secret_key_exists(context);
+    dc_ensure_secret_key_exists(context).ok();
     ongoing_allocated = dc_alloc_ongoing(context);
     if !(ongoing_allocated == 0i32) {
         qr_scan = dc_check_qr(context, qr);
@@ -264,10 +263,7 @@ unsafe fn send_handshake_msg(
 ) {
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     (*msg).type_0 = Viewtype::Text;
-    (*msg).text = dc_mprintf(
-        b"Secure-Join: %s\x00" as *const u8 as *const libc::c_char,
-        step,
-    );
+    (*msg).text = Some(format!("Secure-Join: {}", to_string(step)));
     (*msg).hidden = 1;
     (*msg).param.set_int(Param::Cmd, 7);
     if step.is_null() {
@@ -299,14 +295,12 @@ unsafe fn send_handshake_msg(
 }
 
 unsafe fn chat_id_2_contact_id(context: &Context, contact_chat_id: uint32_t) -> uint32_t {
-    let mut contact_id: uint32_t = 0i32 as uint32_t;
-    let contacts: *mut dc_array_t = dc_get_chat_contacts(context, contact_chat_id);
-    if !(dc_array_get_cnt(contacts) != 1) {
-        contact_id = dc_array_get_id(contacts, 0i32 as size_t)
+    let contacts = dc_get_chat_contacts(context, contact_chat_id);
+    if contacts.len() == 1 {
+        contacts[0]
+    } else {
+        0
     }
-    dc_array_unref(contacts);
-
-    contact_id
 }
 
 unsafe fn fingerprint_equals_sender(
@@ -318,31 +312,23 @@ unsafe fn fingerprint_equals_sender(
         return 0;
     }
     let mut fingerprint_equal: libc::c_int = 0i32;
-    let contacts: *mut dc_array_t = dc_get_chat_contacts(context, contact_chat_id);
-    let contact: *mut dc_contact_t = dc_contact_new(context);
+    let contacts = dc_get_chat_contacts(context, contact_chat_id);
 
-    if !(dc_array_get_cnt(contacts) != 1) {
-        if !dc_contact_load_from_db(
-            contact,
-            &context.sql,
-            dc_array_get_id(contacts, 0i32 as size_t),
-        ) {
+    if contacts.len() == 1 {
+        if let Ok(contact) = Contact::load_from_db(context, contacts[0]) {
+            if let Some(peerstate) = Peerstate::from_addr(context, &context.sql, contact.get_addr())
+            {
+                let fingerprint_normalized = dc_normalize_fingerprint(as_str(fingerprint));
+                if peerstate.public_key_fingerprint.is_some()
+                    && &fingerprint_normalized == peerstate.public_key_fingerprint.as_ref().unwrap()
+                {
+                    fingerprint_equal = 1;
+                }
+            }
+        } else {
             return 0;
         }
-
-        if let Some(peerstate) =
-            Peerstate::from_addr(context, &context.sql, as_str((*contact).addr))
-        {
-            let fingerprint_normalized = dc_normalize_fingerprint(as_str(fingerprint));
-            if peerstate.public_key_fingerprint.is_some()
-                && &fingerprint_normalized == peerstate.public_key_fingerprint.as_ref().unwrap()
-            {
-                fingerprint_equal = 1;
-            }
-        }
     }
-    dc_contact_unref(contact);
-    dc_array_unref(contacts);
 
     fingerprint_equal
 }
@@ -363,7 +349,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
     let mut contact_chat_id_blocked: libc::c_int = 0i32;
     let mut grpid: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut ret: libc::c_int = 0i32;
-    let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
+
     if !(contact_id <= 9i32 as libc::c_uint) {
         step = lookup_field(mimeparser, "Secure-Join");
         if !step.is_null() {
@@ -575,7 +561,11 @@ pub unsafe fn dc_handle_securejoin_handshake(
                         );
                         current_block = 4378276786830486580;
                     } else {
-                        dc_scaleup_contact_origin(context, contact_id, 0x1000000i32);
+                        Contact::scaleup_origin_by_id(
+                            context,
+                            contact_id,
+                            Origin::SecurejoinInvited,
+                        );
                         info!(context, 0, "Auth verified.",);
                         secure_connection_established(context, contact_chat_id);
                         context.call_cb(
@@ -702,16 +692,23 @@ pub unsafe fn dc_handle_securejoin_handshake(
                                     );
                                     current_block = 4378276786830486580;
                                 } else {
-                                    dc_scaleup_contact_origin(context, contact_id, 0x2000000i32);
+                                    Contact::scaleup_origin_by_id(
+                                        context,
+                                        contact_id,
+                                        Origin::SecurejoinJoined,
+                                    );
                                     context.call_cb(
                                         Event::CONTACTS_CHANGED,
                                         0i32 as uintptr_t,
                                         0i32 as uintptr_t,
                                     );
                                     if 0 != join_vg {
-                                        if 0 == dc_addr_equals_self(
+                                        if !addr_equals_self(
                                             context,
-                                            lookup_field(mimeparser, "Chat-Group-Member-Added"),
+                                            as_str(lookup_field(
+                                                mimeparser,
+                                                "Chat-Group-Member-Added",
+                                            )),
                                         ) {
                                             info!(
                                                 context,
@@ -759,22 +756,26 @@ pub unsafe fn dc_handle_securejoin_handshake(
                 ====              Alice - the inviter side              ====
                 ====  Step 8 in "Out-of-band verified groups" protocol  ====
                 ============================================================ */
-                contact = dc_get_contact(context, contact_id);
-                if contact.is_null() || 0 == dc_contact_is_verified(contact) {
+                if let Ok(contact) = Contact::get_by_id(context, contact_id) {
+                    if contact.is_verified() == VerifiedStatus::Unverified {
+                        warn!(context, 0, "vg-member-added-received invalid.",);
+                        current_block = 4378276786830486580;
+                    } else {
+                        context.call_cb(
+                            Event::SECUREJOIN_INVITER_PROGRESS,
+                            contact_id as uintptr_t,
+                            800i32 as uintptr_t,
+                        );
+                        context.call_cb(
+                            Event::SECUREJOIN_INVITER_PROGRESS,
+                            contact_id as uintptr_t,
+                            1000i32 as uintptr_t,
+                        );
+                        current_block = 10256747982273457880;
+                    }
+                } else {
                     warn!(context, 0, "vg-member-added-received invalid.",);
                     current_block = 4378276786830486580;
-                } else {
-                    context.call_cb(
-                        Event::SECUREJOIN_INVITER_PROGRESS,
-                        contact_id as uintptr_t,
-                        800i32 as uintptr_t,
-                    );
-                    context.call_cb(
-                        Event::SECUREJOIN_INVITER_PROGRESS,
-                        contact_id as uintptr_t,
-                        1000i32 as uintptr_t,
-                    );
-                    current_block = 10256747982273457880;
                 }
             } else {
                 current_block = 10256747982273457880;
@@ -789,7 +790,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
             }
         }
     }
-    dc_contact_unref(contact);
+
     free(scanned_fingerprint_of_alice as *mut libc::c_void);
     free(auth as *mut libc::c_void);
     free(own_fingerprint as *mut libc::c_void);
@@ -805,23 +806,20 @@ unsafe fn end_bobs_joining(context: &Context, status: libc::c_int) {
 
 unsafe fn secure_connection_established(context: &Context, contact_chat_id: uint32_t) {
     let contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id);
-    let contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
-    let msg = CString::new(context.stock_string_repl_str(
-        StockMessage::ContactVerified,
-        if !contact.is_null() {
-            as_str((*contact).addr)
-        } else {
-            "?"
-        },
-    ))
-    .unwrap();
+    let contact = Contact::get_by_id(context, contact_id);
+    let addr = if let Ok(ref contact) = contact {
+        contact.get_addr()
+    } else {
+        "?"
+    };
+    let msg =
+        CString::new(context.stock_string_repl_str(StockMessage::ContactVerified, addr)).unwrap();
     dc_add_device_msg(context, contact_chat_id, msg.as_ptr());
     context.call_cb(
         Event::CHAT_MODIFIED,
         contact_chat_id as uintptr_t,
         0i32 as uintptr_t,
     );
-    dc_contact_unref(contact);
 }
 
 unsafe fn lookup_field(mimeparser: &dc_mimeparser_t, key: &str) -> *const libc::c_char {
@@ -847,11 +845,11 @@ unsafe fn could_not_establish_secure_connection(
     details: *const libc::c_char,
 ) {
     let contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id);
-    let contact = dc_get_contact(context, contact_id);
+    let contact = Contact::get_by_id(context, contact_id);
     let msg = context.stock_string_repl_str(
         StockMessage::ContactNotVerified,
-        if !contact.is_null() {
-            as_str((*contact).addr)
+        if let Ok(ref contact) = contact {
+            contact.get_addr()
         } else {
             "?"
         },
@@ -859,7 +857,6 @@ unsafe fn could_not_establish_secure_connection(
     let msg_c = CString::new(msg.as_str()).unwrap();
     dc_add_device_msg(context, contact_chat_id, msg_c.as_ptr());
     error!(context, 0, "{} ({})", msg, as_str(details));
-    dc_contact_unref(contact);
 }
 
 unsafe fn mark_peer_as_verified(

src/dc_simplify.rs

@@ -3,19 +3,18 @@ use crate::dc_tools::*;
 use crate::x::*;
 
 #[derive(Copy, Clone)]
-#[repr(C)]
-pub struct dc_simplify_t {
-    pub is_forwarded: libc::c_int,
-    pub is_cut_at_begin: libc::c_int,
-    pub is_cut_at_end: libc::c_int,
+pub struct Simplify {
+    pub is_forwarded: bool,
+    pub is_cut_at_begin: bool,
+    pub is_cut_at_end: bool,
 }
 
-impl dc_simplify_t {
+impl Simplify {
     pub fn new() -> Self {
-        dc_simplify_t {
-            is_forwarded: 0,
-            is_cut_at_begin: 0,
-            is_cut_at_end: 0,
+        Simplify {
+            is_forwarded: false,
+            is_cut_at_begin: false,
+            is_cut_at_end: false,
         }
     }
 
@@ -26,15 +25,19 @@ impl dc_simplify_t {
         &mut self,
         in_unterminated: *const libc::c_char,
         in_bytes: libc::c_int,
-        is_html: libc::c_int,
+        is_html: bool,
         is_msgrmsg: libc::c_int,
     ) -> *mut libc::c_char {
+        if in_bytes <= 0 {
+            return "".strdup();
+        }
+
         /* create a copy of the given buffer */
         let mut out: *mut libc::c_char;
         let mut temp: *mut libc::c_char;
-        self.is_forwarded = 0i32;
-        self.is_cut_at_begin = 0i32;
-        self.is_cut_at_end = 0i32;
+        self.is_forwarded = false;
+        self.is_cut_at_begin = false;
+        self.is_cut_at_end = false;
         out = strndup(
             in_unterminated as *mut libc::c_char,
             in_bytes as libc::c_ulong,
@@ -42,7 +45,7 @@ impl dc_simplify_t {
         if out.is_null() {
             return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
         }
-        if 0 != is_html {
+        if is_html {
             temp = dc_dehtml(out);
             if !temp.is_null() {
                 free(out as *mut libc::c_void);
@@ -92,7 +95,7 @@ impl dc_simplify_t {
                 || strcmp(line, b"----\x00" as *const u8 as *const libc::c_char) == 0i32
             {
                 footer_mark = 1i32;
-                self.is_cut_at_end = 1i32
+                self.is_cut_at_end = true
             }
             if 0 != footer_mark {
                 l_last = l;
@@ -111,7 +114,7 @@ impl dc_simplify_t {
                 && strncmp(line1, b"From: \x00" as *const u8 as *const libc::c_char, 6) == 0i32
                 && *line2.offset(0isize) as libc::c_int == 0i32
             {
-                self.is_forwarded = 1i32;
+                self.is_forwarded = true;
                 l_first += 3
             }
         }
@@ -124,7 +127,7 @@ impl dc_simplify_t {
                 || strncmp(line, b"~~~~~\x00" as *const u8 as *const libc::c_char, 5) == 0i32
             {
                 l_last = l;
-                self.is_cut_at_end = 1i32;
+                self.is_cut_at_end = true;
                 /* done */
                 break;
             }
@@ -141,7 +144,7 @@ impl dc_simplify_t {
             }
             if l_lastQuotedLine.is_some() {
                 l_last = l_lastQuotedLine.unwrap();
-                self.is_cut_at_end = 1i32;
+                self.is_cut_at_end = true;
                 if l_last > 1 {
                     if is_empty_line(lines[l_last - 1]) {
                         l_last -= 1
@@ -176,12 +179,12 @@ impl dc_simplify_t {
             }
             if l_lastQuotedLine_0.is_some() {
                 l_first = l_lastQuotedLine_0.unwrap() + 1;
-                self.is_cut_at_begin = 1i32
+                self.is_cut_at_begin = true
             }
         }
         /* re-create buffer from the remaining lines */
         let mut ret = String::new();
-        if 0 != self.is_cut_at_begin {
+        if self.is_cut_at_begin {
             ret += "[...]";
         }
         /* we write empty lines only in case and non-empty line follows */
@@ -207,7 +210,7 @@ impl dc_simplify_t {
                 pending_linebreaks = 1i32
             }
         }
-        if 0 != self.is_cut_at_end && (0 == self.is_cut_at_begin || 0 != content_lines_added) {
+        if self.is_cut_at_end && (!self.is_cut_at_begin || 0 != content_lines_added) {
             ret += " [...]";
         }
         dc_free_splitted_lines(lines);
@@ -264,11 +267,11 @@ mod tests {
     #[test]
     fn test_simplify_trim() {
         unsafe {
-            let mut simplify = dc_simplify_t::new();
+            let mut simplify = Simplify::new();
             let html: *const libc::c_char =
                 b"\r\r\nline1<br>\r\n\r\n\r\rline2\n\r\x00" as *const u8 as *const libc::c_char;
             let plain: *mut libc::c_char =
-                simplify.simplify(html, strlen(html) as libc::c_int, 1, 0);
+                simplify.simplify(html, strlen(html) as libc::c_int, true, 0);
 
             assert_eq!(
                 CStr::from_ptr(plain as *const libc::c_char)
@@ -284,11 +287,11 @@ mod tests {
     #[test]
     fn test_simplify_parse_href() {
         unsafe {
-            let mut simplify = dc_simplify_t::new();
+            let mut simplify = Simplify::new();
             let html: *const libc::c_char =
                 b"<a href=url>text</a\x00" as *const u8 as *const libc::c_char;
             let plain: *mut libc::c_char =
-                simplify.simplify(html, strlen(html) as libc::c_int, 1, 0);
+                simplify.simplify(html, strlen(html) as libc::c_int, true, 0);
 
             assert_eq!(
                 CStr::from_ptr(plain as *const libc::c_char)
@@ -304,12 +307,12 @@ mod tests {
     #[test]
     fn test_simplify_bold_text() {
         unsafe {
-            let mut simplify = dc_simplify_t::new();
+            let mut simplify = Simplify::new();
             let html: *const libc::c_char =
                 b"<!DOCTYPE name [<!DOCTYPE ...>]><!-- comment -->text <b><?php echo ... ?>bold</b><![CDATA[<>]]>\x00"
                 as *const u8 as *const libc::c_char;
             let plain: *mut libc::c_char =
-                simplify.simplify(html, strlen(html) as libc::c_int, 1, 0);
+                simplify.simplify(html, strlen(html) as libc::c_int, true, 0);
 
             assert_eq!(
                 CStr::from_ptr(plain as *const libc::c_char)
@@ -325,12 +328,12 @@ mod tests {
     #[test]
     fn test_simplify_html_encoded() {
         unsafe {
-            let mut simplify = dc_simplify_t::new();
+            let mut simplify = Simplify::new();
             let html: *const libc::c_char =
                 b"&lt;&gt;&quot;&apos;&amp; &auml;&Auml;&ouml;&Ouml;&uuml;&Uuml;&szlig; foo&AElig;&ccedil;&Ccedil; &diams;&noent;&lrm;&rlm;&zwnj;&zwj;\x00"
                 as *const u8 as *const libc::c_char;
             let plain: *mut libc::c_char =
-                simplify.simplify(html, strlen(html) as libc::c_int, 1, 0);
+                simplify.simplify(html, strlen(html) as libc::c_int, true, 0);
 
             assert_eq!(
                 strcmp(plain,

src/dc_strencode.rs

@@ -120,97 +120,90 @@ fn hex_2_int(ch: libc::c_char) -> libc::c_char {
 }
 
 pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut libc::c_char {
-    let mut current_block: u64;
+    let mut ok_to_continue = true;
     let mut ret_str: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut cur: *const libc::c_char = to_encode;
     let mmapstr: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
     if to_encode.is_null() || mmapstr.is_null() {
-        current_block = 8550051112593613029;
-    } else {
-        current_block = 4644295000439058019;
+        ok_to_continue = false;
     }
     loop {
-        match current_block {
-            8550051112593613029 => {
-                if !mmapstr.is_null() {
-                    mmap_string_free(mmapstr);
-                }
-                break;
+        if !ok_to_continue {
+            if !mmapstr.is_null() {
+                mmap_string_free(mmapstr);
             }
-            _ => {
-                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)
-                        }
+            break;
+        } else {
+            if *cur as libc::c_int != '\u{0}' as i32 {
+                let begin: *const libc::c_char;
+                let mut end: *const libc::c_char;
+                let mut do_quote: bool;
+                let mut quote_words: libc::c_int;
+                begin = cur;
+                end = begin;
+                quote_words = 0i32;
+                do_quote = true;
+                while *cur as libc::c_int != '\u{0}' as i32 {
+                    get_word(cur, &mut cur, &mut do_quote);
+                    if !do_quote {
+                        break;
                     }
-                    if 0 != quote_words {
-                        if !quote_word(
-                            b"utf-8\x00" as *const u8 as *const libc::c_char,
-                            mmapstr,
-                            begin,
-                            end.wrapping_offset_from(begin) as size_t,
-                        ) {
-                            current_block = 8550051112593613029;
-                            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() {
-                                current_block = 8550051112593613029;
-                                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 size_t,
-                            )
-                            .is_null()
-                            {
-                                current_block = 8550051112593613029;
-                                continue;
-                            }
-                        }
-                    } else if mmap_string_append_len(
+                    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(
+                        b"utf-8\x00" as *const u8 as *const libc::c_char,
                         mmapstr,
                         begin,
-                        cur.wrapping_offset_from(begin) as size_t,
-                    )
-                    .is_null()
-                    {
-                        current_block = 8550051112593613029;
+                        end.wrapping_offset_from(begin) as size_t,
+                    ) {
+                        ok_to_continue = false;
                         continue;
                     }
-                    if !(*cur as libc::c_int == ' ' as i32 || *cur as libc::c_int == '\t' as i32) {
-                        current_block = 4644295000439058019;
-                        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 mmap_string_append_c(mmapstr, *cur).is_null() {
-                        current_block = 8550051112593613029;
-                        continue;
+                    if *end as libc::c_int != '\u{0}' as i32 {
+                        if mmap_string_append_len(
+                            mmapstr,
+                            end,
+                            cur.wrapping_offset_from(end) as size_t,
+                        )
+                        .is_null()
+                        {
+                            ok_to_continue = false;
+                            continue;
+                        }
                     }
-                    cur = cur.offset(1isize);
-                    current_block = 4644295000439058019;
-                } else {
-                    ret_str = strdup((*mmapstr).str_0);
-                    current_block = 8550051112593613029;
+                } else if mmap_string_append_len(
+                    mmapstr,
+                    begin,
+                    cur.wrapping_offset_from(begin) as 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;
             }
         }
     }

src/dc_tools.rs

@@ -23,8 +23,21 @@ pub fn dc_exactly_one_bit_set(v: libc::c_int) -> bool {
     0 != v && 0 == v & v - 1i32
 }
 
-/* string tools */
-/* dc_strdup() returns empty string if NULL is given, never returns NULL (exits on errors) */
+/// Duplicates a string
+///
+/// returns an empty string if NULL is given, never returns NULL (exits on errors)
+///
+/// # Examples
+///
+/// ```
+/// use deltachat::dc_tools::{dc_strdup, to_string};
+/// unsafe {
+///     let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
+///     let str_a_copy = dc_strdup(str_a);
+///     assert_eq!(to_string(str_a_copy), "foobar");
+///     assert_ne!(str_a, str_a_copy);
+/// }
+/// ```
 pub unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
     let ret: *mut libc::c_char;
     if !s.is_null() {
@@ -38,7 +51,21 @@ pub unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
     ret
 }
 
-/* strdup(NULL) is undefined, safe_strdup_keep_null(NULL) returns NULL in this case */
+/// Duplicates a string, returns null if given string is null
+///
+/// # Examples
+///
+/// ```
+/// use deltachat::dc_tools::{dc_strdup_keep_null, to_string};
+/// use std::ffi::{CStr};
+///
+/// unsafe {
+///     let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
+///     let str_a_copy = dc_strdup_keep_null(str_a);
+///     assert_eq!(to_string(str_a_copy), "foobar");
+///     assert_ne!(str_a, str_a_copy);
+/// }
+/// ```
 pub unsafe fn dc_strdup_keep_null(s: *const libc::c_char) -> *mut libc::c_char {
     return if !s.is_null() {
         dc_strdup(s)
@@ -67,50 +94,14 @@ pub unsafe fn dc_str_replace(
     haystack: *mut *mut libc::c_char,
     needle: *const libc::c_char,
     replacement: *const libc::c_char,
-) -> libc::c_int {
-    let mut replacements: libc::c_int = 0i32;
-    let mut start_search_pos: libc::c_int = 0i32;
-    let needle_len: libc::c_int;
-    let replacement_len: libc::c_int;
-    if haystack.is_null()
-        || (*haystack).is_null()
-        || needle.is_null()
-        || *needle.offset(0isize) as libc::c_int == 0i32
-    {
-        return 0i32;
-    }
-    needle_len = strlen(needle) as libc::c_int;
-    replacement_len = (if !replacement.is_null() {
-        strlen(replacement)
-    } else {
-        0
-    }) as libc::c_int;
-    loop {
-        let mut p2: *mut libc::c_char =
-            strstr((*haystack).offset(start_search_pos as isize), needle);
-        if p2.is_null() {
-            break;
-        }
-        start_search_pos =
-            (p2.wrapping_offset_from(*haystack) + replacement_len as isize) as libc::c_int;
-        *p2 = 0i32 as libc::c_char;
-        p2 = p2.offset(needle_len as isize);
-        let new_string: *mut libc::c_char = dc_mprintf(
-            b"%s%s%s\x00" as *const u8 as *const libc::c_char,
-            *haystack,
-            if !replacement.is_null() {
-                replacement
-            } else {
-                b"\x00" as *const u8 as *const libc::c_char
-            },
-            p2,
-        );
-        free(*haystack as *mut libc::c_void);
-        *haystack = new_string;
-        replacements += 1
-    }
+) {
+    let haystack_s = to_string(*haystack);
+    let needle_s = to_string(needle);
+    let replacement_s = to_string(replacement);
 
-    replacements
+    free(*haystack as *mut libc::c_void);
+
+    *haystack = haystack_s.replace(&needle_s, &replacement_s).strdup();
 }
 
 pub unsafe fn dc_ftoa(f: libc::c_double) -> *mut libc::c_char {
@@ -539,32 +530,32 @@ pub unsafe fn dc_str_to_clist(
     list
 }
 
+/* the colors must fulfill some criterions as:
+- contrast to black and to white
+- work as a text-color
+- being noticeable on a typical map
+- harmonize together while being different enough
+(therefore, we cannot just use random rgb colors :) */
+const COLORS: [u32; 16] = [
+    0xe56555, 0xf28c48, 0x8e85ee, 0x76c84d, 0x5bb6cc, 0x549cdd, 0xd25c99, 0xb37800, 0xf23030,
+    0x39b249, 0xbb243b, 0x964078, 0x66874f, 0x308ab9, 0x127ed0, 0xbe450c,
+];
+
+pub fn dc_str_to_color_safe(s: impl AsRef<str>) -> u32 {
+    let str_lower = s.as_ref().to_lowercase();
+    let mut checksum = 0;
+    let bytes = str_lower.as_bytes();
+    for i in 0..str_lower.len() {
+        checksum += (i + 1) * bytes[i] as usize;
+        checksum %= 0xffffff;
+    }
+    let color_index = checksum % COLORS.len();
+
+    COLORS[color_index]
+}
+
 pub unsafe fn dc_str_to_color(str: *const libc::c_char) -> libc::c_int {
     let str_lower: *mut libc::c_char = dc_strlower(str);
-    /* the colors must fulfill some criterions as:
-    - contrast to black and to white
-    - work as a text-color
-    - being noticeable on a typical map
-    - harmonize together while being different enough
-    (therefore, we cannot just use random rgb colors :) */
-    static mut COLORS: [uint32_t; 16] = [
-        0xe56555i32 as uint32_t,
-        0xf28c48i32 as uint32_t,
-        0x8e85eei32 as uint32_t,
-        0x76c84di32 as uint32_t,
-        0x5bb6cci32 as uint32_t,
-        0x549cddi32 as uint32_t,
-        0xd25c99i32 as uint32_t,
-        0xb37800i32 as uint32_t,
-        0xf23030i32 as uint32_t,
-        0x39b249i32 as uint32_t,
-        0xbb243bi32 as uint32_t,
-        0x964078i32 as uint32_t,
-        0x66874fi32 as uint32_t,
-        0x308ab9i32 as uint32_t,
-        0x127ed0i32 as uint32_t,
-        0xbe450ci32 as uint32_t,
-    ];
     let mut checksum: libc::c_int = 0i32;
     let str_len: libc::c_int = strlen(str_lower) as libc::c_int;
     let mut i: libc::c_int = 0i32;
@@ -1036,6 +1027,26 @@ pub unsafe fn dc_get_filemeta(
     0
 }
 
+/// Expand paths relative to $BLOBDIR into absolute paths.
+///
+/// If `path` starts with "$BLOBDIR", replaces it with the blobdir path.
+/// Otherwise, returns path as is.
+pub fn dc_get_abs_path_safe<P: AsRef<std::path::Path>>(
+    context: &Context,
+    path: P,
+) -> std::path::PathBuf {
+    let p: &std::path::Path = path.as_ref();
+    if let Ok(p) = p.strip_prefix("$BLOBDIR") {
+        assert!(
+            context.has_blobdir(),
+            "Expected context to have blobdir to substitute $BLOBDIR",
+        );
+        std::path::PathBuf::from(as_str(context.get_blobdir())).join(p)
+    } else {
+        p.into()
+    }
+}
+
 #[allow(non_snake_case)]
 pub unsafe fn dc_get_abs_path(
     context: &Context,
@@ -1066,137 +1077,75 @@ pub unsafe fn dc_get_abs_path(
     pathNfilename_abs
 }
 
-#[allow(non_snake_case)]
-pub unsafe fn dc_file_exist(context: &Context, pathNfilename: *const libc::c_char) -> libc::c_int {
-    let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
-    if pathNfilename_abs.is_null() {
-        return 0;
-    }
-
-    let exist = {
-        let p = std::path::Path::new(as_str(pathNfilename_abs));
-        p.exists()
-    };
-
-    free(pathNfilename_abs as *mut libc::c_void);
-    exist as libc::c_int
+pub fn dc_file_exist(context: &Context, path: impl AsRef<std::path::Path>) -> bool {
+    dc_get_abs_path_safe(context, &path).exists()
 }
 
-#[allow(non_snake_case)]
-pub unsafe fn dc_get_filebytes(context: &Context, pathNfilename: *const libc::c_char) -> uint64_t {
-    let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
-    if pathNfilename_abs.is_null() {
-        return 0;
+pub fn dc_get_filebytes(context: &Context, path: impl AsRef<std::path::Path>) -> uint64_t {
+    let path_abs = dc_get_abs_path_safe(context, &path);
+    match fs::metadata(&path_abs) {
+        Ok(meta) => meta.len() as uint64_t,
+        Err(_err) => 0,
     }
-
-    let p = std::ffi::CStr::from_ptr(pathNfilename_abs)
-        .to_str()
-        .unwrap();
-    let filebytes = match fs::metadata(p) {
-        Ok(meta) => meta.len(),
-        Err(_err) => {
-            return 0;
-        }
-    };
-
-    free(pathNfilename_abs as *mut libc::c_void);
-    filebytes as uint64_t
 }
 
-#[allow(non_snake_case)]
-pub unsafe fn dc_delete_file(context: &Context, pathNfilename: *const libc::c_char) -> libc::c_int {
-    let mut success: libc::c_int = 0i32;
-    let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
-    if pathNfilename_abs.is_null() {
-        return 0;
-    }
-    let p = std::path::Path::new(
-        std::ffi::CStr::from_ptr(pathNfilename_abs)
-            .to_str()
-            .unwrap(),
-    );
-
-    let res = if p.is_file() {
-        fs::remove_file(p)
+pub fn dc_delete_file(context: &Context, path: impl AsRef<std::path::Path>) -> bool {
+    let path_abs = dc_get_abs_path_safe(context, &path);
+    let res = if path_abs.is_file() {
+        fs::remove_file(path_abs)
     } else {
-        fs::remove_dir_all(p)
+        fs::remove_dir_all(path_abs)
     };
 
     match res {
-        Ok(_) => {
-            success = 1;
-        }
+        Ok(_) => true,
         Err(_err) => {
-            warn!(context, 0, "Cannot delete \"{}\".", as_str(pathNfilename),);
+            warn!(context, 0, "Cannot delete \"{}\".", path.as_ref().display());
+            false
         }
     }
-
-    free(pathNfilename_abs as *mut libc::c_void);
-    success
 }
 
-#[allow(non_snake_case)]
-pub unsafe fn dc_copy_file(
+pub fn dc_copy_file(
     context: &Context,
-    src: *const libc::c_char,
-    dest: *const libc::c_char,
-) -> libc::c_int {
-    let mut success = 0;
-
-    let src_abs = dc_get_abs_path(context, src);
-    let dest_abs = dc_get_abs_path(context, dest);
-
-    if src_abs.is_null() || dest_abs.is_null() {
-        return 0;
-    }
-
-    let src_p = std::ffi::CStr::from_ptr(src_abs).to_str().unwrap();
-    let dest_p = std::ffi::CStr::from_ptr(dest_abs).to_str().unwrap();
-
-    match fs::copy(src_p, dest_p) {
-        Ok(_) => {
-            success = 1;
-        }
+    src: impl AsRef<std::path::Path>,
+    dest: impl AsRef<std::path::Path>,
+) -> bool {
+    let src_abs = dc_get_abs_path_safe(context, &src);
+    let dest_abs = dc_get_abs_path_safe(context, &dest);
+    match fs::copy(&src_abs, &dest_abs) {
+        Ok(_) => true,
         Err(_) => {
-            error!(context, 0, "Cannot copy \"{}\" to \"{}\".", src_p, dest_p,);
+            error!(
+                context,
+                0,
+                "Cannot copy \"{}\" to \"{}\".",
+                src.as_ref().display(),
+                dest.as_ref().display(),
+            );
+            false
         }
     }
-
-    free(src_abs as *mut libc::c_void);
-    free(dest_abs as *mut libc::c_void);
-    success
 }
 
-#[allow(non_snake_case)]
-pub unsafe fn dc_create_folder(
-    context: &Context,
-    pathNfilename: *const libc::c_char,
-) -> libc::c_int {
-    let mut success = 0;
-    let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
-    {
-        let p = std::path::Path::new(as_str(pathNfilename_abs));
-        if !p.exists() {
-            match fs::create_dir_all(p) {
-                Ok(_) => {
-                    success = 1;
-                }
-                Err(_err) => {
-                    warn!(
-                        context,
-                        0,
-                        "Cannot create directory \"{}\".",
-                        as_str(pathNfilename),
-                    );
-                }
+pub fn dc_create_folder(context: &Context, path: impl AsRef<std::path::Path>) -> bool {
+    let path_abs = dc_get_abs_path_safe(context, &path);
+    if !path_abs.exists() {
+        match fs::create_dir_all(path_abs) {
+            Ok(_) => true,
+            Err(_err) => {
+                warn!(
+                    context,
+                    0,
+                    "Cannot create directory \"{}\".",
+                    path.as_ref().display(),
+                );
+                false
             }
-        } else {
-            success = 1;
         }
+    } else {
+        true
     }
-
-    free(pathNfilename_abs as *mut libc::c_void);
-    success
 }
 
 #[allow(non_snake_case)]
@@ -1211,33 +1160,24 @@ pub unsafe fn dc_write_file(
     dc_write_file_safe(context, as_str(pathNfilename), bytes) as libc::c_int
 }
 
-#[allow(non_snake_case)]
-pub fn dc_write_file_safe(context: &Context, pathNfilename: impl AsRef<str>, buf: &[u8]) -> bool {
-    let pathNfilename_abs = unsafe {
-        let n = CString::yolo(pathNfilename.as_ref());
-        dc_get_abs_path(context, n.as_ptr())
-    };
-    if pathNfilename_abs.is_null() {
-        return false;
-    }
-
-    let p = as_str(pathNfilename_abs);
-
-    let success = if let Err(_err) = fs::write(p, buf) {
+pub fn dc_write_file_safe<P: AsRef<std::path::Path>>(
+    context: &Context,
+    path: P,
+    buf: &[u8],
+) -> bool {
+    let path_abs = dc_get_abs_path_safe(context, &path);
+    if let Err(_err) = fs::write(&path_abs, buf) {
         warn!(
             context,
             0,
             "Cannot write {} bytes to \"{}\".",
             buf.len(),
-            pathNfilename.as_ref(),
+            path.as_ref().display(),
         );
         false
     } else {
         true
-    };
-
-    unsafe { free(pathNfilename_abs as *mut libc::c_void) };
-    success
+    }
 }
 
 #[allow(non_snake_case)]
@@ -1260,34 +1200,20 @@ pub unsafe fn dc_read_file(
     }
 }
 
-#[allow(non_snake_case)]
-pub fn dc_read_file_safe(context: &Context, pathNfilename: impl AsRef<str>) -> Option<Vec<u8>> {
-    let pathNfilename_abs = unsafe {
-        let n = CString::yolo(pathNfilename.as_ref());
-        dc_get_abs_path(context, n.as_ptr())
-    };
-
-    if pathNfilename_abs.is_null() {
-        return None;
-    }
-
-    let p = as_str(pathNfilename_abs);
-    let res = match fs::read(p) {
+pub fn dc_read_file_safe<P: AsRef<std::path::Path>>(context: &Context, path: P) -> Option<Vec<u8>> {
+    let path_abs = dc_get_abs_path_safe(context, &path);
+    match fs::read(&path_abs) {
         Ok(bytes) => Some(bytes),
         Err(_err) => {
             warn!(
                 context,
                 0,
                 "Cannot read \"{}\" or file is empty.",
-                pathNfilename.as_ref(),
+                path.as_ref().display()
             );
             None
         }
-    };
-
-    unsafe { free(pathNfilename_abs as *mut libc::c_void) };
-
-    res
+    }
 }
 
 #[allow(non_snake_case)]
@@ -1327,7 +1253,7 @@ pub unsafe fn dc_get_fine_pathNfilename(
                 dotNSuffix,
             )
         }
-        if 0 == dc_file_exist(context, ret) {
+        if !dc_file_exist(context, as_path(ret)) {
             /* fine filename found */
             break;
         } else {
@@ -1381,7 +1307,7 @@ pub unsafe fn dc_make_rel_and_copy(context: &Context, path: *mut *mut libc::c_ch
                     );
                     blobdir_path.is_null()
                 }
-                || 0 == dc_copy_file(context, *path, blobdir_path))
+                || !dc_copy_file(context, as_path(*path), as_path(blobdir_path)))
             {
                 free(*path as *mut libc::c_void);
                 *path = blobdir_path;
@@ -1523,9 +1449,9 @@ pub trait StrExt {
     ///
     /// This allocates a new raw C string which must be freed using
     /// `free`.  It takes care of some common pitfalls with using
-    /// [CString::as_ptr].
+    /// [CString.as_ptr].
     ///
-    /// [CString::as_ptr]: std::ffi::CString::as_ptr
+    /// [CString.as_ptr]: std::ffi::CString.as_ptr
     ///
     /// # Panics
     ///
@@ -1634,6 +1560,49 @@ mod tests {
     use super::*;
     use std::ffi::CStr;
 
+    #[test]
+    fn test_dc_strdup() {
+        unsafe {
+            let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
+            let str_a_copy = dc_strdup(str_a);
+
+            // Value of str_a_copy should equal foobar
+            assert_eq!(
+                CStr::from_ptr(str_a_copy),
+                CString::new("foobar").unwrap().as_c_str()
+            );
+            // Address of str_a should be different from str_a_copy
+            assert_ne!(str_a, str_a_copy);
+
+            let str_a = std::ptr::null() as *const libc::c_char;
+            let str_a_copy = dc_strdup(str_a);
+            // Value of str_a_copy should equal ""
+            assert_eq!(
+                CStr::from_ptr(str_a_copy),
+                CString::new("").unwrap().as_c_str()
+            );
+            assert_ne!(str_a, str_a_copy);
+        }
+    }
+
+    #[test]
+    fn test_dc_strdup_keep_null() {
+        unsafe {
+            let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
+            let str_a_copy = dc_strdup_keep_null(str_a);
+            assert_eq!(
+                CStr::from_ptr(str_a_copy),
+                CString::new("foobar").unwrap().as_c_str()
+            );
+            assert_ne!(str_a, str_a_copy);
+
+            let str_a = 0 as *const u8 as *const libc::c_char;
+            let str_a_copy = dc_strdup_keep_null(str_a);
+            assert_eq!(str_a.is_null(), true);
+            assert_eq!(str_a_copy.is_null(), true);
+        }
+    }
+
     #[test]
     fn test_dc_ltrim() {
         unsafe {
@@ -1708,7 +1677,7 @@ mod tests {
     fn test_dc_str_replace() {
         unsafe {
             let mut str: *mut libc::c_char = strdup(b"aaa\x00" as *const u8 as *const libc::c_char);
-            let replacements: libc::c_int = dc_str_replace(
+            dc_str_replace(
                 &mut str,
                 b"a\x00" as *const u8 as *const libc::c_char,
                 b"ab\x00" as *const u8 as *const libc::c_char,
@@ -1717,7 +1686,6 @@ mod tests {
                 CStr::from_ptr(str as *const libc::c_char).to_str().unwrap(),
                 "ababab"
             );
-            assert_eq!(replacements, 3);
             free(str as *mut libc::c_void);
         }
     }
@@ -2146,5 +2114,4 @@ mod tests {
         let grpid = dc_extract_grpid_from_rfc724_mid(mid);
         assert_eq!(grpid, Some("1234567890123456"));
     }
-
 }

src/keyhistory.rs

@@ -1,13 +0,0 @@
-use crate::context::Context;
-
-/* yes: uppercase */
-/* library private: key-history */
-pub fn dc_add_to_keyhistory(
-    _context: &Context,
-    _rfc724_mid: *const libc::c_char,
-    _sending_time: u64,
-    _addr: *const libc::c_char,
-    _fingerprint: *const libc::c_char,
-) {
-
-}

src/lib.rs

@@ -21,10 +21,10 @@ pub mod aheader;
 pub mod chatlist;
 pub mod config;
 pub mod constants;
+pub mod contact;
 pub mod context;
 pub mod imap;
 pub mod key;
-pub mod keyhistory;
 pub mod keyring;
 pub mod oauth2;
 pub mod param;
@@ -39,7 +39,6 @@ pub mod x;
 pub mod dc_array;
 pub mod dc_chat;
 pub mod dc_configure;
-pub mod dc_contact;
 pub mod dc_dehtml;
 pub mod dc_e2ee;
 pub mod dc_imex;

src/peerstate.rs

@@ -166,7 +166,6 @@ impl<'a> Peerstate<'a> {
 
     pub fn from_addr(context: &'a Context, _sql: &Sql, addr: &str) -> Option<Self> {
         let query = "SELECT addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint FROM acpeerstates  WHERE addr=? COLLATE NOCASE;";
-
         Self::from_stmt(context, query, &[addr])
     }
 
@@ -191,6 +190,11 @@ impl<'a> Peerstate<'a> {
         context
             .sql
             .query_row(query, params, |row| {
+                /* all the above queries start with this: SELECT
+                addr, last_seen, last_seen_autocrypt, prefer_encrypted,
+                public_key, gossip_timestamp, gossip_key, public_key_fingerprint,
+                gossip_key_fingerprint, verified_key, verified_key_fingerprint
+                */
                 let mut res = Self::new(context);
 
                 res.addr = Some(row.get(0)?);
@@ -198,13 +202,34 @@ impl<'a> Peerstate<'a> {
                 res.last_seen_autocrypt = row.get(2)?;
                 res.prefer_encrypt = EncryptPreference::from_i32(row.get(3)?).unwrap_or_default();
                 res.gossip_timestamp = row.get(5)?;
-                let pkf: String = row.get(7)?;
-                res.public_key_fingerprint = if pkf.is_empty() { None } else { Some(pkf) };
-                let gkf: String = row.get(8)?;
-                res.gossip_key_fingerprint = if gkf.is_empty() { None } else { Some(gkf) };
-                let vkf: String = row.get(10)?;
-                res.verified_key_fingerprint = if vkf.is_empty() { None } else { Some(vkf) };
 
+                res.public_key_fingerprint = row.get(7)?;
+                if res
+                    .public_key_fingerprint
+                    .as_ref()
+                    .map(|s| s.is_empty())
+                    .unwrap_or_default()
+                {
+                    res.public_key_fingerprint = None;
+                }
+                res.gossip_key_fingerprint = row.get(8)?;
+                if res
+                    .gossip_key_fingerprint
+                    .as_ref()
+                    .map(|s| s.is_empty())
+                    .unwrap_or_default()
+                {
+                    res.gossip_key_fingerprint = None;
+                }
+                res.verified_key_fingerprint = row.get(10)?;
+                if res
+                    .verified_key_fingerprint
+                    .as_ref()
+                    .map(|s| s.is_empty())
+                    .unwrap_or_default()
+                {
+                    res.verified_key_fingerprint = None;
+                }
                 res.public_key = row
                     .get(4)
                     .ok()
@@ -217,7 +242,8 @@ impl<'a> Peerstate<'a> {
                     .get(9)
                     .ok()
                     .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
-                res.verified_key = if vk == res.gossip_key {
+
+                res.verified_key = if vk == res.gossip_key && res.gossip_key.is_some() {
                     VerifiedKey::Gossip
                 } else if vk == res.public_key {
                     VerifiedKey::Public
@@ -422,6 +448,7 @@ impl<'a> Peerstate<'a> {
                     &self.addr,
                 ],
             ).is_ok();
+            assert_eq!(success, true);
         } else if self.to_save == Some(ToSave::Timestamps) {
             success = sql::execute(
                 self.context,
@@ -498,6 +525,40 @@ mod tests {
         assert_eq!(peerstate, peerstate_new);
     }
 
+    #[test]
+    fn test_peerstate_with_empty_gossip_key_save_to_db() {
+        let ctx = crate::test_utils::dummy_context();
+        let addr = "hello@mail.com";
+
+        let pub_key = crate::key::Key::from_base64("xsBNBFztUVkBCADYaQl/UOUpRPd32nLRzx8eU0eI+jQEnG+g5anjYA+3oct1rROGl5SygjMULDKdaUy27O3o9Srsti0YjA7uxZnavIqhSopJhFidqY1M1wA9JZa/duucZdNwUGbjGIRsS/4Cjr5+3svscK24hVYub1dvDWXpwUTnj3K6xOEnJdoM+MhCqtSD5+zcJhFc9vyZm9ZTGWUxAhKh0iJTcCD8V6CQ3XZ2z9GruwzZT/FTFovWrz7m3TUI2OdSSHh0eZLRGEoxMCT/vzflAFGAr8ijCaRsEIfqP6FW8uQWnFTqkjxEUCZG6XkeFHB84aj5jqYG/1KCLjL5vEKwfl1tz/WnPhY7ABEBAAHNEDxoZWxsb0BtYWlsLmNvbT7CwIkEEAEIADMCGQEFAlztUVoCGwMECwkIBwYVCAkKCwIDFgIBFiEEgMjHGVbvLXe6ioRROg8oKCvye7gACgkQOg8oKCvye7ijAwf+PTsuawUax9cNPn1bN90H+g9qyHZJMEwKXtUnNaXJxPW3iB7ThhpCiCzsZwP7+l7ArS8tmLeNDw2bENtcf1XCv4wovP2fdXOP3QOUUFX/GdakcTwv7DzC7CO0grB1HtaPhGw/6UX2o2cx2i9xiUf4Givq2MfCbgAW5zloH6WXGPb6yLQYJXxqDIphr4+uZDb+bMAyWHN/DUkAjHrV8nnVki7PMHqzzZpwglalxMX8RGeiGZE39ALJKL/Og87DMFah87/yoxQWGoS7Wqv0XDcCPKoTCPrpk8pOe2KEsq/lz215nefHd4aRpfUX5YCYa8HPvvfPQbGF73uvyQw5w7qjis7ATQRc7VFZAQgAt8ONdnX6KEEQ5Jw6ilJ+LBtY44SP5t0I3eK+goKepgIiKhjGDa+Mntyi4jdhH+HO6kvK5SHMh2sPp4rRO/WKHJwWFySyM1OdyiywhyH0J9R5rBY4vPHsJjf6vSKJdWLWT+ho1fNet2IIC+jVCYli91MAMbRvk6EKVj1nCc+67giOahXEkHt6xxkeCGlOvbw8hxGj1A8+AC1BLms/OR3oc4JMi9O3kq6uG0z9tlUEerac9HVwcjoO1XLe+hJhoT5H+TbnGjPuhuURP3pFiIKHpbRYgUfdSAY0dTObO7t4I5y/drPOrCTnWrBUg2wXAECUhpRKow9/ai2YemLv9KqhhwARAQABwsB2BBgBCAAgBQJc7VFaAhsMFiEEgMjHGVbvLXe6ioRROg8oKCvye7gACgkQOg8oKCvye7jmyggAhs4QzCzIbT2OsAReBxkxtm0AI+g1HZ1KFKof5NDHfgv9C/Qu1I8mKEjlZzA4qFyPmLqntgwJ0RuFy6gLbljZBNCFO7vB478AhYtnWjuKZmA40HUPwcB1hEJ31c42akzfUbioY1TLLepngdsJg7Cm8O+rhI9+1WRA66haJDgFs793SVUDyJh8f9NX50l5zR87/bsV30CFSw0q4OSSy9VI/z+2g5khn1LnuuOrCfFnYIPYtJED1BfkXkosxGlgbzy79VvGmI9d23x4atDK7oBPCzIj+lP8sytJ0u3HOguXi9OgDitKy+Pt1r8gH8frdktMJr5Ts6DW+tIn2vR23KR8aA==", KeyType::Public).unwrap();
+
+        let mut peerstate = Peerstate {
+            context: &ctx.ctx,
+            addr: Some(addr.into()),
+            last_seen: 10,
+            last_seen_autocrypt: 11,
+            prefer_encrypt: EncryptPreference::Mutual,
+            public_key: Some(pub_key.clone()),
+            public_key_fingerprint: Some(pub_key.fingerprint()),
+            gossip_key: None,
+            gossip_timestamp: 12,
+            gossip_key_fingerprint: None,
+            verified_key: VerifiedKey::None,
+            verified_key_fingerprint: None,
+            to_save: Some(ToSave::All),
+            degrade_event: None,
+        };
+
+        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");
+
+        // clear to_save, as that is not persissted
+        peerstate.to_save = None;
+        assert_eq!(peerstate, peerstate_new);
+    }
+
     // TODO: don't copy this from stress.rs
     #[allow(dead_code)]
     struct TestContext {

src/sql.rs

@@ -4,7 +4,6 @@ use std::sync::{Arc, RwLock};
 use rusqlite::{Connection, OpenFlags, Statement, NO_PARAMS};
 use thread_local_object::ThreadLocal;
 
-use crate::constants::*;
 use crate::context::Context;
 use crate::dc_tools::*;
 use crate::error::{Error, Result};
@@ -689,10 +688,6 @@ fn open(
                 "ALTER TABLE msgs ADD COLUMN move_state INTEGER DEFAULT 1;",
                 params![],
             )?;
-            assert_eq!(DC_MOVE_STATE_UNDEFINED as libc::c_int, 0);
-            assert_eq!(DC_MOVE_STATE_PENDING as libc::c_int, 1);
-            assert_eq!(DC_MOVE_STATE_STAY as libc::c_int, 2);
-            assert_eq!(DC_MOVE_STATE_MOVING as libc::c_int, 3);
 
             dbversion = 48;
             sql.set_config_int(context, "dbversion", 48)?;
@@ -1047,10 +1042,8 @@ pub fn housekeeping(context: &Context) {
                     unreferenced_count,
                     entry.file_name()
                 );
-                unsafe {
-                    let path = entry.path().to_c_string().unwrap();
-                    dc_delete_file(context, path.as_ptr());
-                }
+                let path = entry.path();
+                dc_delete_file(context, path);
             }
         }
         Err(err) => {

src/stock.rs

@@ -1,12 +1,11 @@
 use std::borrow::Cow;
-use std::ffi::CString;
 
 use strum::EnumProperty;
 use strum_macros::EnumProperty;
 
 use crate::constants::Event;
+use crate::contact::*;
 use crate::context::Context;
-use crate::dc_contact::*;
 use crate::dc_tools::*;
 use libc::free;
 
@@ -200,40 +199,30 @@ impl Context {
         from_id: u32,
     ) -> String {
         let insert1 = if id == StockMessage::MsgAddMember || id == StockMessage::MsgDelMember {
-            unsafe {
-                let param1_c = CString::new(param1.as_ref()).unwrap();
-                let contact_id = dc_lookup_contact_id_by_addr(self, param1_c.as_ptr());
-                if contact_id != 0 {
-                    let contact = dc_get_contact(self, contact_id);
-                    let displayname = dc_contact_get_name_n_addr(contact);
-                    let ret = to_string(displayname);
-                    free(contact as *mut libc::c_void);
-                    free(displayname as *mut libc::c_void);
-                    ret
-                } else {
-                    param1.as_ref().to_string()
-                }
+            let contact_id = Contact::lookup_id_by_addr(self, param1.as_ref());
+            if contact_id != 0 {
+                Contact::get_by_id(self, contact_id)
+                    .map(|contact| contact.get_name_n_addr())
+                    .unwrap_or_default()
+            } else {
+                param1.as_ref().to_string()
             }
         } else {
             param1.as_ref().to_string()
         };
+
         let action = self.stock_string_repl_str2(id, insert1, param2.as_ref().to_string());
         let action1 = action.trim_end_matches('.');
         match from_id {
             0 => action,
             1 => self.stock_string_repl_str(StockMessage::MsgActionByMe, action1), // DC_CONTACT_ID_SELF
-            _ => unsafe {
-                let contact = dc_get_contact(self, from_id);
-                let displayname = dc_contact_get_display_name(contact);
-                let ret = self.stock_string_repl_str2(
-                    StockMessage::MsgActionByUser,
-                    action1,
-                    as_str(displayname),
-                );
-                free(contact as *mut libc::c_void);
-                free(displayname as *mut libc::c_void);
-                ret
-            },
+            _ => {
+                let displayname = Contact::get_by_id(self, from_id)
+                    .map(|contact| contact.get_name_n_addr())
+                    .unwrap_or_default();
+
+                self.stock_string_repl_str2(StockMessage::MsgActionByUser, action1, &displayname)
+            }
         }
     }
 }
@@ -343,11 +332,7 @@ mod tests {
     #[test]
     fn test_stock_system_msg_add_member_by_me_with_displayname() {
         let t = dummy_context();
-        unsafe {
-            let name = CString::new("Alice").unwrap();
-            let addr = CString::new("alice@example.com").unwrap();
-            assert!(dc_create_contact(&t.ctx, name.as_ptr(), addr.as_ptr()) > 0);
-        }
+        Contact::create(&t.ctx, "Alice", "alice@example.com").expect("failed to create contact");
         assert_eq!(
             t.ctx.stock_system_msg(
                 StockMessage::MsgAddMember,
@@ -356,23 +341,17 @@ mod tests {
                 DC_CONTACT_ID_SELF as u32
             ),
             "Member Alice (alice@example.com) added by me."
-        )
+        );
     }
 
     #[test]
     fn test_stock_system_msg_add_member_by_other_with_displayname() {
         let t = dummy_context();
-        let contact_id = unsafe {
-            let name = CString::new("Alice").unwrap();
-            let addr = CString::new("alice@example.com").unwrap();
-            assert!(
-                dc_create_contact(&t.ctx, name.as_ptr(), addr.as_ptr()) > 0,
-                "Failed to create contact Alice"
-            );
-            let name = CString::new("Bob").unwrap();
-            let addr = CString::new("bob@example.com").unwrap();
-            let id = dc_create_contact(&t.ctx, name.as_ptr(), addr.as_ptr());
-            assert!(id > 0, "Failed to create contact Bob");
+        let contact_id = {
+            Contact::create(&t.ctx, "Alice", "alice@example.com")
+                .expect("Failed to create contact Alice");
+            let id =
+                Contact::create(&t.ctx, "Bob", "bob@example.com").expect("failed to create bob");
             id
         };
         assert_eq!(
@@ -382,8 +361,8 @@ mod tests {
                 "",
                 contact_id,
             ),
-            "Member Alice (alice@example.com) added by Bob."
-        )
+            "Member Alice (alice@example.com) added by Bob (bob@example.com)."
+        );
     }
 
     #[test]
@@ -403,21 +382,13 @@ mod tests {
     #[test]
     fn test_stock_system_msg_grp_name_other() {
         let t = dummy_context();
-        let contact_id = unsafe {
-            let name = CString::new("Alice").unwrap();
-            let addr = CString::new("alice@example.com").unwrap();
-            let id = dc_create_contact(&t.ctx, name.as_ptr(), addr.as_ptr());
-            assert!(id > 0, "Failed to create contact Alice");
-            id
-        };
+        let id = Contact::create(&t.ctx, "Alice", "alice@example.com")
+            .expect("failed to create contact");
+
         assert_eq!(
-            t.ctx.stock_system_msg(
-                StockMessage::MsgGrpName,
-                "Some chat",
-                "Other chat",
-                contact_id
-            ),
-            "Group name changed from \"Some chat\" to \"Other chat\" by Alice."
+            t.ctx
+                .stock_system_msg(StockMessage::MsgGrpName, "Some chat", "Other chat", id,),
+            "Group name changed from \"Some chat\" to \"Other chat\" by Alice (alice@example.com)."
         )
     }
 }

src/test_utils.rs

@@ -2,9 +2,15 @@
 //!
 //! This module is only compiled for test runs.
 
+use std::ffi::CStr;
+
+use libc::uintptr_t;
 use tempfile::{tempdir, TempDir};
 
+use crate::config::Config;
+use crate::constants::{Event, KeyType};
 use crate::context::{dc_context_new, dc_open, Context};
+use crate::key;
 use crate::types::dc_callback_t;
 
 /// A Context and temporary directory.
@@ -44,3 +50,127 @@ pub fn test_context(cb: Option<dc_callback_t>) -> TestContext {
 pub fn dummy_context() -> TestContext {
     test_context(None)
 }
+
+pub unsafe extern "C" fn logging_cb(
+    _ctx: &Context,
+    evt: Event,
+    _d1: uintptr_t,
+    d2: uintptr_t,
+) -> uintptr_t {
+    let to_str = |x| CStr::from_ptr(x as *const libc::c_char).to_str().unwrap();
+    match evt {
+        Event::INFO => println!("I: {}", to_str(d2)),
+        Event::WARNING => println!("W: {}", to_str(d2)),
+        Event::ERROR => println!("E: {}", to_str(d2)),
+        _ => (),
+    }
+    0
+}
+
+/// Creates Alice with a pre-generated keypair.
+///
+/// Returns the address of the keypair created (alice@example.org).
+pub fn configure_alice_keypair(ctx: &Context) -> String {
+    let addr = String::from("alice@example.org");
+    ctx.set_config(Config::ConfiguredAddr, Some(&addr)).unwrap();
+
+    // The keypair was created using:
+    //   let (public, private) = crate::pgp::dc_pgp_create_keypair("alice@example.com")
+    //       .unwrap();
+    //   println!("{}", public.to_base64(64));
+    //   println!("{}", private.to_base64(64));
+    let public = key::Key::from_base64(
+        concat!(
+            "xsBNBF086ewBCACmJKuoxIO6T87yi4Q3MyNpMch3Y8KrtHDQyUszU36eqM3Pmd1l",
+            "FrbcCd8ZWo2pq6OJSwsM/jjRGn1zo2YOaQeJRRrC+KrKGqSUtRSYQBPrPjE2YjSX",
+            "AMbu8jBI6VVUhHeghriBkK79PY9O/oRhIJC0p14IJe6CQ6OI2fTmTUHF9i/nJ3G4",
+            "Wb3/K1bU3yVfyPZjTZQPYPvvh03vxHULKurtYkX5DTEMSWsF4qzLMps+l87VuLV9",
+            "iQnbN7YMRLHHx2KkX5Ivi7JCefhCa54M0K3bDCCxuVWAM5wjQwNZjzR+WL+dYchw",
+            "oFvuF8NrlzjM9dSv+2rn+J7f99ijSXarzPC7ABEBAAHNEzxhbGljZUBleGFtcGxl",
+            "LmNvbT7CwIkEEAEIADMCGQEFAl086fgCGwMECwkIBwYVCAkKCwIDFgIBFiEE+iai",
+            "x4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcei3ogf/cruUmQ+th52TFHTHdkw9",
+            "OHUl3MrXtZ7QmHyOAFvbXE/6n5Eeh+eZoF8MWWV72m14Wbs+vTcNQkFVTdOPptkK",
+            "A8e4cJqwDOHsyAnvQXZ7WNje9+BMzcoipIUawHP4ORFaPDsKLZQ0b4wBbKn8ziea",
+            "6zjGF0/qljTdoxTtsYpv5wXYuhwbYklrLOqgSa5M7LXUe7E3g9mbg+9iX1GuB8m6",
+            "GkquJN814Y+xny4xhZzGOfue6SeP12jJMNSjSP7416dRq7794VGnkkW9V/7oFEUK",
+            "u5wO9FFbgDySOSlEjByGejSGuBmho0iJSjcPjZ7EY/j3M3orq4dpza5C82OeSvxD",
+            "Fc7ATQRdPOnsAQgA5oLxXRLnyugzOmNCy7dxV3JrDZscA6JNlJlDWIShT0YSs+zG",
+            "9JzDeQql+sYXgUSxOoIayItuXtnFn7tstwGoOnYvadm/e5/7V5fKAQRtCtdN51av",
+            "62n18Venlm0yNKpROPcZ6M/sc4m6uU6YRZ/a1idal8VGY0wLKlghjIBuIiBoVQ/R",
+            "noW+/fhmwIg08dQ5m8hQe3GEOZEeLrTWL/9awPlXK7Y+DmJOoR4qbHWEcRfbzS6q",
+            "4zW8vk2ztB8ngwbnqYy8zrN1DCICN1gYdlU++uVw6Bb1XfY8Cdldh1VLKpF35mAm",
+            "jxLZfVDcoObFH3Cv2GB7BEYxv86KC2Y6T74Q/wARAQABwsB2BBgBCAAgBQJdPOn4",
+            "AhsMFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcegLxwf/dXshJnoW",
+            "qEnRsf6rVb9/Mc66ti+NVQLfNd275dybh/QIJdK3NmSxdnTPIEJRVspJywJoupwX",
+            "FNrnHG2Ff6QPvHqI+/oNu986r9d7Z1oQibbLHKt8t6kpOfg/xGxotagJuiCQvR9m",
+            "MjD1DqsdB37SjDxGupZOOJSXWi6KX60IE+uM+QOBfeOZziQwuFmA5wV6RDXIeYJf",
+            "qrcbeXeR1d0nfNpPHQR1gBiqmxNb6KBbdXD2+EXW60axC7D2b1APmzMlammDliPw",
+            "sK9U1rc9nuquEBvGDOJf4K+Dzn+mDCqRpP6uAuQ7RKHyim4uyN0wwKObzPqgJCGw",
+            "jTglkixw+aSTXw=="
+        ),
+        KeyType::Public,
+    )
+    .unwrap();
+    let private = key::Key::from_base64(
+        concat!(
+            "xcLYBF086ewBCACmJKuoxIO6T87yi4Q3MyNpMch3Y8KrtHDQyUszU36eqM3Pmd1l",
+            "FrbcCd8ZWo2pq6OJSwsM/jjRGn1zo2YOaQeJRRrC+KrKGqSUtRSYQBPrPjE2YjSX",
+            "AMbu8jBI6VVUhHeghriBkK79PY9O/oRhIJC0p14IJe6CQ6OI2fTmTUHF9i/nJ3G4",
+            "Wb3/K1bU3yVfyPZjTZQPYPvvh03vxHULKurtYkX5DTEMSWsF4qzLMps+l87VuLV9",
+            "iQnbN7YMRLHHx2KkX5Ivi7JCefhCa54M0K3bDCCxuVWAM5wjQwNZjzR+WL+dYchw",
+            "oFvuF8NrlzjM9dSv+2rn+J7f99ijSXarzPC7ABEBAAEACAChqzVOuErmVRqvcYtq",
+            "m1xt1H+ZjX20z5Sn1fhTLYAcq236AWMqJvwxCXoKlc8bt2UfB+Ls9cQb1YcVq353",
+            "r0QiExiDeK3YlCxqd/peXJwFYTNKFC3QcnUhtpG9oS/jWjN+BRotGbjtu6Vj3M68",
+            "JJAq+mHJ0/9OyrqrREvGfo7uLZt7iMGemDlrDakvrbIyZrPLgay+nZ3dEFKeOQ6F",
+            "FrU05jyUVdoHBy0Tqx/6VpFUX9+IHcMHL2lTJB0nynBj+XZ/G4aX3WYoo3YlixHb",
+            "Iu35fGFA0TChoGaGPzqcI/kg2Z+b/BryG9NM3LA2cO8iGrGXAE1nPFp91jmCrQ3V",
+            "WushBADERP+uojjjfdO5J+RkmcFe9mFYDdtkhN+kV+LdePjiNNtcXMBhasstio0S",
+            "ut0GKnE7DFRhX7mkN9w2apJ2ooeFeVVWot18eSdp6Rzh6/1Z7TmhYFJ3oUxxLbnQ",
+            "sWIXIec1SzqWBFJUCn3IP0mCnJktFg/uGW6yLs01r5ds52uSBQQA2LSWiTwk9tEm",
+            "dr9mz3tHnmrkyGiyKhKGM1Z7Rch63D5yQc1s4kUMBlyuLL2QtM/e4dtaz2JAkO8k",
+            "QrYCnNgJ+2roTAK3kDZgYtymjdvK3HpQNtjVo7dds5RJVb6U618phZwU5WNFAEJW",
+            "yyImmycGfjLv+18cW/3mq0QVZejkM78D/2kHaIeJAowtBOFY2zDrKyDRoBHaUSgj",
+            "5BjGoviRC5rYihWDEyYDQ6mBJQstAD0Ty3MYzyUxl6ruB/BMWnMDFq5+TqtdBzu3",
+            "jCtZ8OEyH8A5Kdo68Wzo/PGxzMtusOdNj9+3PBmSq4yibJxbLSrn59aVUYpGLjeG",
+            "Kyvm9OTKkrOGN27NEzxhbGljZUBleGFtcGxlLmNvbT7CwIkEEAEIADMCGQEFAl08",
+            "6fgCGwMECwkIBwYVCAkKCwIDFgIBFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQ",
+            "k6DcNkbrcei3ogf/cruUmQ+th52TFHTHdkw9OHUl3MrXtZ7QmHyOAFvbXE/6n5Ee",
+            "h+eZoF8MWWV72m14Wbs+vTcNQkFVTdOPptkKA8e4cJqwDOHsyAnvQXZ7WNje9+BM",
+            "zcoipIUawHP4ORFaPDsKLZQ0b4wBbKn8ziea6zjGF0/qljTdoxTtsYpv5wXYuhwb",
+            "YklrLOqgSa5M7LXUe7E3g9mbg+9iX1GuB8m6GkquJN814Y+xny4xhZzGOfue6SeP",
+            "12jJMNSjSP7416dRq7794VGnkkW9V/7oFEUKu5wO9FFbgDySOSlEjByGejSGuBmh",
+            "o0iJSjcPjZ7EY/j3M3orq4dpza5C82OeSvxDFcfC2ARdPOnsAQgA5oLxXRLnyugz",
+            "OmNCy7dxV3JrDZscA6JNlJlDWIShT0YSs+zG9JzDeQql+sYXgUSxOoIayItuXtnF",
+            "n7tstwGoOnYvadm/e5/7V5fKAQRtCtdN51av62n18Venlm0yNKpROPcZ6M/sc4m6",
+            "uU6YRZ/a1idal8VGY0wLKlghjIBuIiBoVQ/RnoW+/fhmwIg08dQ5m8hQe3GEOZEe",
+            "LrTWL/9awPlXK7Y+DmJOoR4qbHWEcRfbzS6q4zW8vk2ztB8ngwbnqYy8zrN1DCIC",
+            "N1gYdlU++uVw6Bb1XfY8Cdldh1VLKpF35mAmjxLZfVDcoObFH3Cv2GB7BEYxv86K",
+            "C2Y6T74Q/wARAQABAAgAhSvFEYZoj1sSrXrHDjZOrryViGjCCH9t3pmkxLDrGIdd",
+            "KsFyN8ORUo6KUZS745yx3yFnI9EZ1IZvm9aF+jxk2lGJFtgLvfoxFOvGckwCSy8T",
+            "/MCiJZkz01hWo5s2VCLJheWL/GqTKjS5wXDcm+y8Wtilh+UawycdlDsSNr/D4MZL",
+            "j3Chq9K03l5UIR8DcC7SavNi55R2oGOfboXsdvwOlrNZdCkZOlXDI4ZKFwbDHCtp",
+            "Do5FS30hnJi2TecUPZWB1CaGFWnevINd4ikugVjcAoZj/QAIvfrOCgqisF/Ylg9u",
+            "RMUPBapmcJUueILwd0iQqvGG0aCqtchvSmlg15/lQQQA9G1NNjNAH+NQrXvDJFJe",
+            "/V1U3F3pz7jCjQa69c0dxSBUeNX1pG8XXD6tSkkd4Ni1mzZGcZXOmVUM6cA9I7RH",
+            "95RqV+QIfnXVneCRrlCjV8m6OBlkivkESXc3nW5wtCIfw7oKg9w1xuVNUaAlbCt9",
+            "QVLaxXJiY7ad0f5U9XJ1+w8EAPFs+M/+GZK1wOZYBL1vo7x0gL9ZggmjC4B+viBJ",
+            "8Q60mqTrphYFsbXHuwKV0g9aIoZMucKyEE0QLR7imttiLEz1nD8bfEScbGy9ZG//",
+            "wRfyJmCVAjA0pQ6LtB93d70PSVzzJrMHgbLKrDuSd6RChl7n9BIEdVyk7LEph0Yg",
+            "9UsRBADm6DvpKL+P3lQ0eLTfAgcQTOqLZDYmI3PvqqSkHb1kHChqOXXs8hGOSSwK",
+            "Gjcd4CZeNOGWR42rZyRhVgtkt6iYviIaVAWUfme6K+sLQBCeyMlmEGtykAA+LmPB",
+            "f4zdyUNADfoxgZF3EKHf6I3nlVn5cdT+o/9vjdY2XAOwcls1RzaFwsB2BBgBCAAg",
+            "BQJdPOn4AhsMFiEE+iaix4d0doj87Q0ek6DcNkbrcegACgkQk6DcNkbrcegLxwf/",
+            "dXshJnoWqEnRsf6rVb9/Mc66ti+NVQLfNd275dybh/QIJdK3NmSxdnTPIEJRVspJ",
+            "ywJoupwXFNrnHG2Ff6QPvHqI+/oNu986r9d7Z1oQibbLHKt8t6kpOfg/xGxotagJ",
+            "uiCQvR9mMjD1DqsdB37SjDxGupZOOJSXWi6KX60IE+uM+QOBfeOZziQwuFmA5wV6",
+            "RDXIeYJfqrcbeXeR1d0nfNpPHQR1gBiqmxNb6KBbdXD2+EXW60axC7D2b1APmzMl",
+            "ammDliPwsK9U1rc9nuquEBvGDOJf4K+Dzn+mDCqRpP6uAuQ7RKHyim4uyN0wwKOb",
+            "zPqgJCGwjTglkixw+aSTXw=="
+        ),
+        KeyType::Private,
+    )
+    .unwrap();
+    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/types.rs

@@ -16,8 +16,6 @@ pub use rusqlite::ffi::*;
 pub type dc_callback_t =
     unsafe extern "C" fn(_: &Context, _: Event, _: uintptr_t, _: uintptr_t) -> uintptr_t;
 
-pub type dc_move_state_t = u32;
-
 pub type dc_receive_imf_t = unsafe fn(
     _: &Context,
     _: *const libc::c_char,

tests/stress.rs

@@ -8,11 +8,10 @@ use tempfile::{tempdir, TempDir};
 
 use deltachat::config;
 use deltachat::constants::*;
+use deltachat::contact::*;
 use deltachat::context::*;
-use deltachat::dc_array::*;
 use deltachat::dc_chat::*;
 use deltachat::dc_configure::*;
-use deltachat::dc_contact::*;
 use deltachat::dc_imex::*;
 use deltachat::dc_location::*;
 use deltachat::dc_lot::*;
@@ -57,39 +56,15 @@ unsafe fn stress_functions(context: &Context) {
     );
 
     if 0 != dc_is_open(context) {
-        if 0 != dc_file_exist(
-            context,
-            b"$BLOBDIR/foobar\x00" as *const u8 as *const libc::c_char,
-        ) || 0
-            != dc_file_exist(
-                context,
-                b"$BLOBDIR/dada\x00" as *const u8 as *const libc::c_char,
-            )
-            || 0 != dc_file_exist(
-                context,
-                b"$BLOBDIR/foobar.dadada\x00" as *const u8 as *const libc::c_char,
-            )
-            || 0 != dc_file_exist(
-                context,
-                b"$BLOBDIR/foobar-folder\x00" as *const u8 as *const libc::c_char,
-            )
+        if dc_file_exist(context, "$BLOBDIR/foobar")
+            || dc_file_exist(context, "$BLOBDIR/dada")
+            || dc_file_exist(context, "$BLOBDIR/foobar.dadada")
+            || dc_file_exist(context, "$BLOBDIR/foobar-folder")
         {
-            dc_delete_file(
-                context,
-                b"$BLOBDIR/foobar\x00" as *const u8 as *const libc::c_char,
-            );
-            dc_delete_file(
-                context,
-                b"$BLOBDIR/dada\x00" as *const u8 as *const libc::c_char,
-            );
-            dc_delete_file(
-                context,
-                b"$BLOBDIR/foobar.dadada\x00" as *const u8 as *const libc::c_char,
-            );
-            dc_delete_file(
-                context,
-                b"$BLOBDIR/foobar-folder\x00" as *const u8 as *const libc::c_char,
-            );
+            dc_delete_file(context, "$BLOBDIR/foobar");
+            dc_delete_file(context, "$BLOBDIR/dada");
+            dc_delete_file(context, "$BLOBDIR/foobar.dadada");
+            dc_delete_file(context, "$BLOBDIR/foobar-folder");
         }
         dc_write_file(
             context,
@@ -97,25 +72,10 @@ unsafe fn stress_functions(context: &Context) {
             b"content\x00" as *const u8 as *const libc::c_char as *const libc::c_void,
             7i32 as size_t,
         );
-        assert_ne!(
-            0,
-            dc_file_exist(
-                context,
-                b"$BLOBDIR/foobar\x00" as *const u8 as *const libc::c_char,
-            )
-        );
+        assert!(dc_file_exist(context, "$BLOBDIR/foobar",));
+        assert!(!dc_file_exist(context, "$BLOBDIR/foobarx"));
         assert_eq!(
-            0,
-            dc_file_exist(
-                context,
-                b"$BLOBDIR/foobarx\x00" as *const u8 as *const libc::c_char,
-            )
-        );
-        assert_eq!(
-            dc_get_filebytes(
-                context,
-                b"$BLOBDIR/foobar\x00" as *const u8 as *const libc::c_char,
-            ),
+            dc_get_filebytes(context, "$BLOBDIR/foobar",),
             7i32 as libc::c_ulonglong
         );
 
@@ -133,23 +93,10 @@ unsafe fn stress_functions(context: &Context) {
             context,
             b"/BLOBDIR/fofo\x00" as *const u8 as *const libc::c_char,
         ));
-        assert_ne!(0, dc_file_exist(context, abs_path));
+        assert!(dc_file_exist(context, as_path(abs_path)));
         free(abs_path as *mut libc::c_void);
-        assert_ne!(
-            0,
-            dc_copy_file(
-                context,
-                b"$BLOBDIR/foobar\x00" as *const u8 as *const libc::c_char,
-                b"$BLOBDIR/dada\x00" as *const u8 as *const libc::c_char,
-            )
-        );
-        assert_eq!(
-            dc_get_filebytes(
-                context,
-                b"$BLOBDIR/dada\x00" as *const u8 as *const libc::c_char,
-            ),
-            7
-        );
+        assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
+        assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada",), 7);
 
         let mut buf: *mut libc::c_void = 0 as *mut libc::c_void;
         let mut buf_bytes: size_t = 0;
@@ -170,41 +117,11 @@ unsafe fn stress_functions(context: &Context) {
         );
 
         free(buf as *mut _);
-        assert_ne!(
-            0,
-            dc_delete_file(
-                context,
-                b"$BLOBDIR/foobar\x00" as *const u8 as *const libc::c_char,
-            )
-        );
-        assert_ne!(
-            0,
-            dc_delete_file(
-                context,
-                b"$BLOBDIR/dada\x00" as *const u8 as *const libc::c_char,
-            )
-        );
-        assert_ne!(
-            0,
-            dc_create_folder(
-                context,
-                b"$BLOBDIR/foobar-folder\x00" as *const u8 as *const libc::c_char,
-            )
-        );
-        assert_ne!(
-            0,
-            dc_file_exist(
-                context,
-                b"$BLOBDIR/foobar-folder\x00" as *const u8 as *const libc::c_char,
-            )
-        );
-        assert_ne!(
-            0,
-            dc_delete_file(
-                context,
-                b"$BLOBDIR/foobar-folder\x00" as *const u8 as *const libc::c_char,
-            )
-        );
+        assert!(dc_delete_file(context, "$BLOBDIR/foobar"));
+        assert!(dc_delete_file(context, "$BLOBDIR/dada"));
+        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: *mut libc::c_char = dc_get_fine_pathNfilename(
             context,
             b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
@@ -237,7 +154,7 @@ unsafe fn stress_functions(context: &Context) {
             ),
             0
         );
-        assert_ne!(0, dc_delete_file(context, fn0));
+        assert!(dc_delete_file(context, as_path(fn0)));
         free(fn0 as *mut libc::c_void);
         free(fn1 as *mut libc::c_void);
     }
@@ -825,22 +742,14 @@ fn test_dc_mimeparser_with_context() {
             "inner-subject",
         );
 
-        let mut of: *mut mailimf_optional_field = dc_mimeparser_lookup_optional_field(
-            &mimeparser,
-            b"X-Special-A\x00" as *const u8 as *const libc::c_char,
-        );
+        let mut of: *mut mailimf_optional_field =
+            dc_mimeparser_lookup_optional_field(&mimeparser, "X-Special-A");
         assert_eq!(as_str((*of).fld_value as *const libc::c_char), "special-a",);
 
-        of = dc_mimeparser_lookup_optional_field(
-            &mimeparser,
-            b"Foo\x00" as *const u8 as *const libc::c_char,
-        );
+        of = dc_mimeparser_lookup_optional_field(&mimeparser, "Foo");
         assert_eq!(as_str((*of).fld_value as *const libc::c_char), "Bar",);
 
-        of = dc_mimeparser_lookup_optional_field(
-            &mimeparser,
-            b"Chat-Version\x00" as *const u8 as *const libc::c_char,
-        );
+        of = dc_mimeparser_lookup_optional_field(&mimeparser, "Chat-Version");
         assert_eq!(as_str((*of).fld_value as *const libc::c_char), "1.0",);
         assert_eq!(mimeparser.parts.len(), 1);
 
@@ -890,24 +799,17 @@ fn test_stress_tests() {
 fn test_get_contacts() {
     unsafe {
         let context = create_test_context();
-        let name = CString::yolo("some2");
-        let contacts = dc_get_contacts(&context.ctx, 0, name.as_ptr());
-        assert_eq!(dc_array_get_cnt(contacts), 0);
-        dc_array_unref(contacts);
+        let contacts = Contact::get_all(&context.ctx, 0, Some("some2")).unwrap();
+        assert_eq!(contacts.len(), 0);
 
-        let name = CString::yolo("bob");
-        let email = CString::yolo("bob@mail.de");
-        let id = dc_create_contact(&context.ctx, name.as_ptr(), email.as_ptr());
+        let id = Contact::create(&context.ctx, "bob", "bob@mail.de").unwrap();
         assert_ne!(id, 0);
 
-        let contacts = dc_get_contacts(&context.ctx, 0, name.as_ptr());
-        assert_eq!(dc_array_get_cnt(contacts), 1);
-        dc_array_unref(contacts);
+        let contacts = Contact::get_all(&context.ctx, 0, Some("bob")).unwrap();
+        assert_eq!(contacts.len(), 1);
 
-        let name2 = CString::yolo("alice");
-        let contacts = dc_get_contacts(&context.ctx, 0, name2.as_ptr());
-        assert_eq!(dc_array_get_cnt(contacts), 0);
-        dc_array_unref(contacts);
+        let contacts = Contact::get_all(&context.ctx, 0, Some("alice")).unwrap();
+        assert_eq!(contacts.len(), 0);
     }
 }
 
@@ -915,10 +817,7 @@ fn test_get_contacts() {
 fn test_chat() {
     unsafe {
         let context = create_test_context();
-        let name = CString::yolo("bob");
-        let email = CString::yolo("bob@mail.de");
-
-        let contact1 = dc_create_contact(&context.ctx, name.as_ptr(), email.as_ptr());
+        let contact1 = Contact::create(&context.ctx, "bob", "bob@mail.de").unwrap();
         assert_ne!(contact1, 0);
 
         let chat_id = dc_create_chat_by_contact_id(&context.ctx, contact1);