diff --git a/src/dc_contact.rs b/src/dc_contact.rs
index f61967833..3f0520291 100644
--- a/src/dc_contact.rs
+++ b/src/dc_contact.rs
@@ -793,11 +793,6 @@ pub unsafe fn dc_get_contact_encrinfo(
                 dc_strbuilder_cat(&mut ret, p);
                 free(p as *mut libc::c_void);
                 if (*self_key).binary.is_null() {
-                    dc_pgp_rand_seed(
-                        context,
-                        (*peerstate).addr as *const libc::c_void,
-                        strlen((*peerstate).addr),
-                    );
                     dc_ensure_secret_key_exists(context);
                     dc_key_load_self_public(self_key, (*loginparam).addr, (*context).sql);
                 }
diff --git a/src/dc_context.rs b/src/dc_context.rs
index ecd85956d..f2068ccd9 100644
--- a/src/dc_context.rs
+++ b/src/dc_context.rs
@@ -1,4 +1,6 @@
 use libc;
+use std::sync::{Arc, Condvar, Mutex, RwLock};
+use std::time::SystemTime;
 
 use crate::constants::VERSION;
 use crate::dc_array::*;
@@ -23,45 +25,35 @@ use crate::dc_tools::*;
 use crate::types::*;
 use crate::x::*;
 
-#[derive(Copy, Clone)]
 #[repr(C)]
 pub struct dc_context_t {
-    pub magic: uint32_t,
     pub userdata: *mut libc::c_void,
     pub dbfile: *mut libc::c_char,
     pub blobdir: *mut libc::c_char,
-    pub sql: *mut dc_sqlite3_t,
-    pub inbox: *mut dc_imap_t,
-    pub inboxidle_condmutex: pthread_mutex_t,
-    pub perform_inbox_jobs_needed: libc::c_int,
-    pub probe_imap_network: libc::c_int,
+    pub sql: dc_sqlite3_t,
+    pub inbox: dc_imap_t,
+    pub perform_inbox_jobs_needed: Arc<RwLock<i32>>,
+    pub probe_imap_network: Arc<RwLock<i32>>,
     pub sentbox_thread: dc_jobthread_t,
     pub mvbox_thread: dc_jobthread_t,
-    pub smtp: *mut dc_smtp_t,
-    pub smtpidle_cond: pthread_cond_t,
-    pub smtpidle_condmutex: pthread_mutex_t,
-    pub smtpidle_condflag: libc::c_int,
-    pub smtp_suspended: libc::c_int,
-    pub smtp_doing_jobs: libc::c_int,
-    pub perform_smtp_jobs_needed: libc::c_int,
-    pub probe_smtp_network: libc::c_int,
-    pub oauth2_critical: pthread_mutex_t,
+    pub smtp: dc_smtp_t,
+    pub smtpidle: Arc<(Mutex<bool>, Condvar)>,
+    pub smtp_suspended: Arc<RwLock<i32>>,
+    pub smtp_doing_jobs: Arc<RwLock<i32>>,
+    pub perform_smtp_jobs_needed: Arc<RwLock<i32>>,
+    pub probe_smtp_network: Arc<RwLock<i32>>,
+    pub oauth2_critical: Arc<Mutex<()>>,
     pub cb: dc_callback_t,
     pub os_name: *mut libc::c_char,
-    pub cmdline_sel_chat_id: uint32_t,
-    pub bob_expects: libc::c_int,
-    pub bobs_status: libc::c_int,
-    pub bobs_qr_scan: *mut dc_lot_t,
-    pub bobs_qr_critical: pthread_mutex_t,
-    pub last_smeared_timestamp: time_t,
-    pub smear_critical: pthread_mutex_t,
-    pub ongoing_running: libc::c_int,
-    pub shall_stop_ongoing: libc::c_int,
+    pub cmdline_sel_chat_id: u32,
+    pub bob_expects: i32,
+    pub bobs_status: i32,
+    pub bobs_qr_scan: Arc<RwLock<*mut dc_lot_t>>,
+    pub last_smeared_timestamp: Arc<RwLock<Option<SystemTime>>>,
+    pub ongoing_running: i32,
+    pub shall_stop_ongoing: i32,
 }
 
-unsafe impl Send for dc_context_t {}
-unsafe impl Sync for dc_context_t {}
-
 // location handling
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -79,111 +71,77 @@ pub struct _dc_location {
 }
 
 // create/open/config/information
-pub unsafe fn dc_context_new(
-    mut cb: dc_callback_t,
-    mut userdata: *mut libc::c_void,
-    mut os_name: *const libc::c_char,
-) -> *mut dc_context_t {
-    let mut context: *mut dc_context_t = 0 as *mut dc_context_t;
-    context = calloc(1, ::std::mem::size_of::<dc_context_t>()) as *mut dc_context_t;
-    if context.is_null() {
-        exit(23i32);
+pub fn dc_context_new(
+    cb: dc_callback_t,
+    userdata: *mut libc::c_void,
+    os_name: *const libc::c_char,
+) -> dc_context_t {
+    dc_context_t {
+        blobdir: std::ptr::null_mut(),
+        dbfile: std::ptr::null_mut(),
+        inbox: unsafe {
+            dc_imap_new(
+                Some(cb_get_config),
+                Some(cb_set_config),
+                Some(cb_precheck_imf),
+                Some(cb_receive_imf),
+            )
+        },
+        userdata,
+        cb,
+        os_name: dc_strdup_keep_null(os_name),
+        ongoing_running: 0,
+        shall_stop_ongoing: 1,
+        sql: dc_sqlite3_new(),
+        smtp: dc_smtp_new(),
+        smtpidle: Arc::new((Mutex::new(false), Condvar::new())),
+        smtp_suspended: Arc::new(RwLock::new(0)),
+        smtp_doing_jobs: Arc::new(RwLock::new(0)),
+        perform_smtp_jobs_needed: Arc::new(RwLock::new(0)),
+        probe_smtp_network: Arc::new(RwLock::new(0)),
+        oauth2_critical: Arc::new(Mutex::new(())),
+        bob_expects: 0,
+        bobs_status: 0,
+        bobs_qr_scan: Arc::new(RwLock::new(std::ptr::null_mut())),
+        last_smeared_timestamp: Arc::new(RwLock::new(None)),
+        cmdline_sel_chat_id: 0,
+        sentbox_thread: unsafe {
+            dc_jobthread_init(
+                b"SENTBOX\x00" as *const u8 as *const libc::c_char,
+                b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
+                dc_imap_new(
+                    Some(cb_get_config),
+                    Some(cb_set_config),
+                    Some(cb_precheck_imf),
+                    Some(cb_receive_imf),
+                ),
+            )
+        },
+        mvbox_thread: unsafe {
+            dc_jobthread_init(
+                b"MVBOX\x00" as *const u8 as *const libc::c_char,
+                b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
+                dc_imap_new(
+                    Some(cb_get_config),
+                    Some(cb_set_config),
+                    Some(cb_precheck_imf),
+                    Some(cb_receive_imf),
+                ),
+            )
+        },
+        probe_imap_network: Arc::new(RwLock::new(0)),
+        perform_inbox_jobs_needed: Arc::new(RwLock::new(0)),
     }
-    pthread_mutex_init(
-        &mut (*context).smear_critical,
-        0 as *const pthread_mutexattr_t,
-    );
-    pthread_mutex_init(
-        &mut (*context).bobs_qr_critical,
-        0 as *const pthread_mutexattr_t,
-    );
-    pthread_mutex_init(
-        &mut (*context).inboxidle_condmutex,
-        0 as *const pthread_mutexattr_t,
-    );
-    dc_jobthread_init(
-        &mut (*context).sentbox_thread,
-        context,
-        b"SENTBOX\x00" as *const u8 as *const libc::c_char,
-        b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
-    );
-    dc_jobthread_init(
-        &mut (*context).mvbox_thread,
-        context,
-        b"MVBOX\x00" as *const u8 as *const libc::c_char,
-        b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
-    );
-    pthread_mutex_init(
-        &mut (*context).smtpidle_condmutex,
-        0 as *const pthread_mutexattr_t,
-    );
-    pthread_cond_init(
-        &mut (*context).smtpidle_cond,
-        0 as *const pthread_condattr_t,
-    );
-    pthread_mutex_init(
-        &mut (*context).oauth2_critical,
-        0 as *const pthread_mutexattr_t,
-    );
-    (*context).magic = 0x11a11807i32 as uint32_t;
-    (*context).userdata = userdata;
-    (*context).cb = cb;
-    (*context).os_name = dc_strdup_keep_null(os_name);
-    (*context).shall_stop_ongoing = 1i32;
-
-    dc_pgp_init();
-    (*context).sql = dc_sqlite3_new(context);
-    (*context).inbox = dc_imap_new(
-        Some(cb_get_config),
-        Some(cb_set_config),
-        Some(cb_precheck_imf),
-        Some(cb_receive_imf),
-        context as *mut libc::c_void,
-        context,
-    );
-    (*context).sentbox_thread.imap = dc_imap_new(
-        Some(cb_get_config),
-        Some(cb_set_config),
-        Some(cb_precheck_imf),
-        Some(cb_receive_imf),
-        context as *mut libc::c_void,
-        context,
-    );
-    (*context).mvbox_thread.imap = dc_imap_new(
-        Some(cb_get_config),
-        Some(cb_set_config),
-        Some(cb_precheck_imf),
-        Some(cb_receive_imf),
-        context as *mut libc::c_void,
-        context,
-    );
-    (*context).smtp = dc_smtp_new(context);
-    /* Random-seed.  An additional seed with more random data is done just before key generation
-    (the timespan between this call and the key generation time is typically random.
-    Moreover, later, we add a hash of the first message data to the random-seed
-    (it would be okay to seed with even more sensible data, the seed values cannot be recovered from the PRNG output, see OpenSSL's RAND_seed()) */
-    let mut seed: [uintptr_t; 5] = [0; 5];
-    seed[0usize] = time(0 as *mut time_t) as uintptr_t;
-    seed[1usize] = seed.as_mut_ptr() as uintptr_t;
-    seed[2usize] = context as uintptr_t;
-    seed[3usize] = pthread_self() as uintptr_t;
-    seed[4usize] = libc::getpid() as uintptr_t;
-    dc_pgp_rand_seed(
-        context,
-        seed.as_mut_ptr() as *const libc::c_void,
-        ::std::mem::size_of::<[uintptr_t; 5]>(),
-    );
-    return context;
 }
+
 unsafe fn cb_receive_imf(
-    mut imap: *mut dc_imap_t,
-    mut imf_raw_not_terminated: *const libc::c_char,
-    mut imf_raw_bytes: size_t,
-    mut server_folder: *const libc::c_char,
-    mut server_uid: uint32_t,
-    mut flags: uint32_t,
+    context: &dc_context,
+    imf_raw_not_terminated: *const libc::c_char,
+    imf_raw_bytes: size_t,
+    server_folder: *const libc::c_char,
+    server_uid: uint32_t,
+    flags: uint32_t,
 ) {
-    let mut context: *mut dc_context_t = (*imap).userData as *mut dc_context_t;
     dc_receive_imf(
         context,
         imf_raw_not_terminated,
@@ -193,11 +151,12 @@ unsafe fn cb_receive_imf(
         flags,
     );
 }
+
 unsafe fn cb_precheck_imf(
-    mut imap: *mut dc_imap_t,
-    mut rfc724_mid: *const libc::c_char,
-    mut server_folder: *const libc::c_char,
-    mut server_uid: uint32_t,
+    context: &dc_context_t,
+    rfc724_mid: *const libc::c_char,
+    server_folder: *const libc::c_char,
+    server_uid: uint32_t,
 ) -> libc::c_int {
     let mut rfc724_mid_exists: libc::c_int = 0i32;
     let mut msg_id: uint32_t = 0i32 as uint32_t;
@@ -205,7 +164,7 @@ unsafe fn cb_precheck_imf(
     let mut old_server_uid: uint32_t = 0i32 as uint32_t;
     let mut mark_seen: libc::c_int = 0i32;
     msg_id = dc_rfc724_mid_exists(
-        (*imap).context,
+        context,
         rfc724_mid,
         &mut old_server_folder,
         &mut old_server_uid,
@@ -216,7 +175,7 @@ unsafe fn cb_precheck_imf(
             && old_server_uid == 0i32 as libc::c_uint
         {
             dc_log_info(
-                (*imap).context,
+                context,
                 0i32,
                 b"[move] detected bbc-self %s\x00" as *const u8 as *const libc::c_char,
                 rfc724_mid,
@@ -224,20 +183,20 @@ unsafe fn cb_precheck_imf(
             mark_seen = 1i32
         } else if strcmp(old_server_folder, server_folder) != 0i32 {
             dc_log_info(
-                (*imap).context,
+                context,
                 0i32,
                 b"[move] detected moved message %s\x00" as *const u8 as *const libc::c_char,
                 rfc724_mid,
             );
-            dc_update_msg_move_state((*imap).context, rfc724_mid, DC_MOVE_STATE_STAY);
+            dc_update_msg_move_state(context, rfc724_mid, DC_MOVE_STATE_STAY);
         }
         if strcmp(old_server_folder, server_folder) != 0i32 || old_server_uid != server_uid {
-            dc_update_server_uid((*imap).context, rfc724_mid, server_folder, server_uid);
+            dc_update_server_uid(context, rfc724_mid, server_folder, server_uid);
         }
-        dc_do_heuristics_moves((*imap).context, server_folder, msg_id);
+        dc_do_heuristics_moves(context, server_folder, msg_id);
         if 0 != mark_seen {
             dc_job_add(
-                (*imap).context,
+                context,
                 130i32,
                 msg_id as libc::c_int,
                 0 as *const libc::c_char,
@@ -249,12 +208,11 @@ unsafe fn cb_precheck_imf(
     return rfc724_mid_exists;
 }
 unsafe fn cb_set_config(
-    mut imap: *mut dc_imap_t,
-    mut key: *const libc::c_char,
-    mut value: *const libc::c_char,
+    context: &dc_context_t,
+    key: *const libc::c_char,
+    value: *const libc::c_char,
 ) {
-    let mut context: *mut dc_context_t = (*imap).userData as *mut dc_context_t;
-    dc_sqlite3_set_config((*context).sql, key, value);
+    dc_sqlite3_set_config(&context.sql, key, value);
 }
 /* *
  * The following three callback are given to dc_imap_new() to read/write configuration
@@ -264,144 +222,121 @@ unsafe fn cb_set_config(
  * @private @memberof dc_context_t
  */
 unsafe fn cb_get_config(
-    mut imap: *mut dc_imap_t,
-    mut key: *const libc::c_char,
-    mut def: *const libc::c_char,
+    context: &dc_context,
+    key: *const libc::c_char,
+    def: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut context: *mut dc_context_t = (*imap).userData as *mut dc_context_t;
-    return dc_sqlite3_get_config((*context).sql, key, def);
+    dc_sqlite3_get_config(context.sql, key, def)
 }
 
-pub unsafe fn dc_context_unref(mut context: *mut dc_context_t) {
-    if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
-        return;
-    }
-    dc_pgp_exit();
+pub unsafe fn dc_context_unref(context: &mut dc_context_t) {
     if 0 != dc_is_open(context) {
         dc_close(context);
     }
-    dc_imap_unref((*context).inbox);
-    dc_imap_unref((*context).sentbox_thread.imap);
-    dc_imap_unref((*context).mvbox_thread.imap);
-    dc_smtp_unref((*context).smtp);
-    dc_sqlite3_unref((*context).sql);
+    dc_imap_unref(&mut context.inbox);
+    dc_imap_unref(&mut context.sentbox_thread.imap);
+    dc_imap_unref(&mut context.mvbox_thread.imap);
+    dc_smtp_unref(&mut context.smtp);
+    dc_sqlite3_unref(&mut context.sql);
 
-    pthread_mutex_destroy(&mut (*context).smear_critical);
-    pthread_mutex_destroy(&mut (*context).bobs_qr_critical);
-    pthread_mutex_destroy(&mut (*context).inboxidle_condmutex);
-    dc_jobthread_exit(&mut (*context).sentbox_thread);
-    dc_jobthread_exit(&mut (*context).mvbox_thread);
-    pthread_cond_destroy(&mut (*context).smtpidle_cond);
-    pthread_mutex_destroy(&mut (*context).smtpidle_condmutex);
-    pthread_mutex_destroy(&mut (*context).oauth2_critical);
-    free((*context).os_name as *mut libc::c_void);
-    (*context).magic = 0i32 as uint32_t;
-    free(context as *mut libc::c_void);
+    dc_jobthread_exit(&mut context.sentbox_thread);
+    dc_jobthread_exit(&mut context.mvbox_thread);
+
+    free(context.os_name as *mut libc::c_void);
 }
-pub unsafe fn dc_close(mut context: *mut dc_context_t) {
-    if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
-        return;
+
+pub unsafe fn dc_close(context: &mut dc_context_t) {
+    dc_imap_disconnect(&mut context.inbox);
+    dc_imap_disconnect(&mut context.sentbox_thread.imap);
+    dc_imap_disconnect(&mut context.mvbox_thread.imap);
+    dc_smtp_disconnect(&mut context.smtp);
+
+    if 0 != dc_sqlite3_is_open(context.sql) {
+        dc_sqlite3_close(context.sql);
     }
-    dc_imap_disconnect((*context).inbox);
-    dc_imap_disconnect((*context).sentbox_thread.imap);
-    dc_imap_disconnect((*context).mvbox_thread.imap);
-    dc_smtp_disconnect((*context).smtp);
-    if 0 != dc_sqlite3_is_open((*context).sql) {
-        dc_sqlite3_close((*context).sql);
-    }
-    free((*context).dbfile as *mut libc::c_void);
-    (*context).dbfile = 0 as *mut libc::c_char;
-    free((*context).blobdir as *mut libc::c_void);
-    (*context).blobdir = 0 as *mut libc::c_char;
+    free(context.dbfile as *mut libc::c_void);
+    context.dbfile = 0 as *mut libc::c_char;
+    free(context.blobdir as *mut libc::c_void);
+    context.blobdir = 0 as *mut libc::c_char;
 }
-pub unsafe fn dc_is_open(mut context: *const dc_context_t) -> libc::c_int {
-    if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
-        return 0i32;
-    }
-    return dc_sqlite3_is_open((*context).sql);
+
+pub unsafe fn dc_is_open(context: &dc_context_t) -> libc::c_int {
+    dc_sqlite3_is_open(context.sql)
 }
-pub unsafe fn dc_get_userdata(mut context: *mut dc_context_t) -> *mut libc::c_void {
-    if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
-        return 0 as *mut libc::c_void;
-    }
-    return (*context).userdata;
+
+pub unsafe fn dc_get_userdata(context: &mut dc_context_t) -> *mut libc::c_void {
+    &mut context.userdata as *mut _
 }
+
 pub unsafe fn dc_open(
-    mut context: *mut dc_context_t,
-    mut dbfile: *const libc::c_char,
-    mut blobdir: *const libc::c_char,
+    context: &mut dc_context_t,
+    dbfile: *const libc::c_char,
+    blobdir: *const libc::c_char,
 ) -> libc::c_int {
-    let mut success: libc::c_int = 0i32;
+    let mut success = 0;
     if 0 != dc_is_open(context) {
-        return 0i32;
+        return 0;
     }
-    if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || dbfile.is_null())
-    {
-        (*context).dbfile = dc_strdup(dbfile);
+    if !dbfile.is_null() {
+        context.dbfile = dc_strdup(dbfile);
         if !blobdir.is_null() && 0 != *blobdir.offset(0isize) as libc::c_int {
-            (*context).blobdir = dc_strdup(blobdir);
-            dc_ensure_no_slash((*context).blobdir);
+            context.blobdir = dc_strdup(blobdir);
+            dc_ensure_no_slash(context.blobdir);
         } else {
-            (*context).blobdir =
+            context.blobdir =
                 dc_mprintf(b"%s-blobs\x00" as *const u8 as *const libc::c_char, dbfile);
-            dc_create_folder(context, (*context).blobdir);
+            dc_create_folder(context, context.blobdir);
         }
-        /* Create/open sqlite database, this may already use the blobdir */
-        if !(0 == dc_sqlite3_open((*context).sql, dbfile, 0i32)) {
+        // Create/open sqlite database, this may already use the blobdir
+        if !(0 == dc_sqlite3_open(&mut context.sql, dbfile, 0i32)) {
             success = 1i32
         }
     }
     if 0 == success {
         dc_close(context);
     }
-    return success;
+    success
 }
-pub unsafe fn dc_get_blobdir(mut context: *const dc_context_t) -> *mut libc::c_char {
-    if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
-        return dc_strdup(0 as *const libc::c_char);
-    }
-    return dc_strdup((*context).blobdir);
+
+pub unsafe fn dc_get_blobdir(context: &dc_context_t) -> *mut libc::c_char {
+    dc_strdup((*context).blobdir)
 }
+
 pub unsafe fn dc_set_config(
-    mut context: *mut dc_context_t,
-    mut key: *const libc::c_char,
-    mut value: *const libc::c_char,
+    context: &dc_context_t,
+    key: *const libc::c_char,
+    value: *const libc::c_char,
 ) -> libc::c_int {
-    let mut ret: libc::c_int = 0i32;
-    let mut rel_path: *mut libc::c_char = 0 as *mut libc::c_char;
-    if context.is_null()
-        || (*context).magic != 0x11a11807i32 as libc::c_uint
-        || key.is_null()
-        || 0 == is_settable_config_key(key)
-    {
-        return 0i32;
+    let mut ret = 0;
+    let mut rel_path = 0 as *mut libc::c_char;
+
+    if key.is_null() || 0 == is_settable_config_key(key) {
+        return 0;
     }
-    if strcmp(key, b"selfavatar\x00" as *const u8 as *const libc::c_char) == 0i32
-        && !value.is_null()
-    {
+    if strcmp(key, b"selfavatar\x00" as *const u8 as *const libc::c_char) == 0 && !value.is_null() {
         rel_path = dc_strdup(value);
         if !(0 == dc_make_rel_and_copy(context, &mut rel_path)) {
-            ret = dc_sqlite3_set_config((*context).sql, key, rel_path)
+            ret = dc_sqlite3_set_config(context.sql, key, rel_path)
         }
-    } else if strcmp(key, b"inbox_watch\x00" as *const u8 as *const libc::c_char) == 0i32 {
-        ret = dc_sqlite3_set_config((*context).sql, key, value);
+    } else if strcmp(key, b"inbox_watch\x00" as *const u8 as *const libc::c_char) == 0 {
+        ret = dc_sqlite3_set_config(&context.sql, key, value);
         dc_interrupt_imap_idle(context);
     } else if strcmp(
         key,
         b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
-    ) == 0i32
+    ) == 0
     {
-        ret = dc_sqlite3_set_config((*context).sql, key, value);
+        ret = dc_sqlite3_set_config(&context.sql, key, value);
         dc_interrupt_sentbox_idle(context);
-    } else if strcmp(key, b"mvbox_watch\x00" as *const u8 as *const libc::c_char) == 0i32 {
-        ret = dc_sqlite3_set_config((*context).sql, key, value);
+    } else if strcmp(key, b"mvbox_watch\x00" as *const u8 as *const libc::c_char) == 0 {
+        ret = dc_sqlite3_set_config(&context.sql, key, value);
         dc_interrupt_mvbox_idle(context);
-    } else if strcmp(key, b"selfstatus\x00" as *const u8 as *const libc::c_char) == 0i32 {
-        let mut def: *mut libc::c_char = dc_stock_str(context, 13i32);
+    } else if strcmp(key, b"selfstatus\x00" as *const u8 as *const libc::c_char) == 0 {
+        let mut def = dc_stock_str(context, 13);
         ret = dc_sqlite3_set_config(
-            (*context).sql,
+            context.sql,
             key,
-            if value.is_null() || strcmp(value, def) == 0i32 {
+            if value.is_null() || strcmp(value, def) == 0 {
                 0 as *const libc::c_char
             } else {
                 value
@@ -409,27 +344,30 @@ pub unsafe fn dc_set_config(
         );
         free(def as *mut libc::c_void);
     } else {
-        ret = dc_sqlite3_set_config((*context).sql, key, value)
+        ret = dc_sqlite3_set_config(&context.sql, key, value);
     }
     free(rel_path as *mut libc::c_void);
-    return ret;
+    ret
 }
+
 /* ******************************************************************************
  * INI-handling, Information
  ******************************************************************************/
-unsafe fn is_settable_config_key(mut key: *const libc::c_char) -> libc::c_int {
+
+unsafe fn is_settable_config_key(key: *const libc::c_char) -> libc::c_int {
     let mut i = 0;
     while i
         < (::std::mem::size_of::<[*const libc::c_char; 33]>())
             .wrapping_div(::std::mem::size_of::<*mut libc::c_char>())
     {
-        if strcmp(key, config_keys[i as usize]) == 0i32 {
-            return 1i32;
+        if strcmp(key, config_keys[i as usize]) == 0 {
+            return 1;
         }
         i += 1
     }
-    return 0i32;
+    0
 }
+
 static mut config_keys: [*const libc::c_char; 33] = [
     b"addr\x00" as *const u8 as *const libc::c_char,
     b"mail_server\x00" as *const u8 as *const libc::c_char,
@@ -465,11 +403,9 @@ static mut config_keys: [*const libc::c_char; 33] = [
     b"configured_server_flags\x00" as *const u8 as *const libc::c_char,
     b"configured\x00" as *const u8 as *const libc::c_char,
 ];
-pub unsafe fn dc_get_config(
-    mut context: *mut dc_context_t,
-    mut key: *const libc::c_char,
-) -> *mut libc::c_char {
-    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
+
+pub unsafe fn dc_get_config(context: &dc_context_t, key: *const libc::c_char) -> *mut libc::c_char {
+    let mut value = 0 as *mut libc::c_char;
     if !key.is_null()
         && *key.offset(0isize) as libc::c_int == 's' as i32
         && *key.offset(1isize) as libc::c_int == 'y' as i32
@@ -478,101 +414,107 @@ pub unsafe fn dc_get_config(
     {
         return get_sys_config_str(key);
     }
-    if context.is_null()
-        || (*context).magic != 0x11a11807i32 as libc::c_uint
-        || key.is_null()
-        || 0 == is_gettable_config_key(key)
-    {
+
+    if key.is_null() || 0 == is_gettable_config_key(key) {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
     }
-    if strcmp(key, b"selfavatar\x00" as *const u8 as *const libc::c_char) == 0i32 {
+
+    if strcmp(key, b"selfavatar\x00" as *const u8 as *const libc::c_char) == 0 {
         let mut rel_path: *mut libc::c_char =
-            dc_sqlite3_get_config((*context).sql, key, 0 as *const libc::c_char);
+            dc_sqlite3_get_config(context.sql, key, 0 as *const libc::c_char);
         if !rel_path.is_null() {
             value = dc_get_abs_path(context, rel_path);
             free(rel_path as *mut libc::c_void);
         }
     } else {
-        value = dc_sqlite3_get_config((*context).sql, key, 0 as *const libc::c_char)
+        value = dc_sqlite3_get_config(context.sql, key, 0 as *const libc::c_char)
     }
+
     if value.is_null() {
-        if strcmp(key, b"e2ee_enabled\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1i32)
-        } else if strcmp(key, b"mdns_enabled\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1i32)
-        } else if strcmp(key, b"imap_folder\x00" as *const u8 as *const libc::c_char) == 0i32 {
+        if strcmp(key, b"e2ee_enabled\x00" as *const u8 as *const libc::c_char) == 0 {
+            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
+        } else if strcmp(key, b"mdns_enabled\x00" as *const u8 as *const libc::c_char) == 0 {
+            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
+        } else if strcmp(key, b"imap_folder\x00" as *const u8 as *const libc::c_char) == 0 {
             value = dc_strdup(b"INBOX\x00" as *const u8 as *const libc::c_char)
-        } else if strcmp(key, b"inbox_watch\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1i32)
+        } else if strcmp(key, b"inbox_watch\x00" as *const u8 as *const libc::c_char) == 0 {
+            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
         } else if strcmp(
             key,
             b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
-        ) == 0i32
+        ) == 0
         {
-            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1i32)
-        } else if strcmp(key, b"mvbox_watch\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1i32)
-        } else if strcmp(key, b"mvbox_move\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1i32)
-        } else if strcmp(key, b"show_emails\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 0i32)
-        } else if strcmp(key, b"selfstatus\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            value = dc_stock_str(context, 13i32)
+            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
+        } else if strcmp(key, b"mvbox_watch\x00" as *const u8 as *const libc::c_char) == 0 {
+            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
+        } else if strcmp(key, b"mvbox_move\x00" as *const u8 as *const libc::c_char) == 0 {
+            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
+        } else if strcmp(key, b"show_emails\x00" as *const u8 as *const libc::c_char) == 0 {
+            value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 0)
+        } else if strcmp(key, b"selfstatus\x00" as *const u8 as *const libc::c_char) == 0 {
+            value = dc_stock_str(context, 13)
         } else {
             value = dc_mprintf(b"\x00" as *const u8 as *const libc::c_char)
         }
     }
-    return value;
+
+    value
 }
-unsafe fn is_gettable_config_key(mut key: *const libc::c_char) -> libc::c_int {
+
+unsafe fn is_gettable_config_key(key: *const libc::c_char) -> libc::c_int {
     let mut i = 0;
     while i
         < (::std::mem::size_of::<[*const libc::c_char; 3]>())
             .wrapping_div(::std::mem::size_of::<*mut libc::c_char>())
     {
-        if strcmp(key, sys_config_keys[i as usize]) == 0i32 {
-            return 1i32;
+        if strcmp(key, sys_config_keys[i as usize]) == 0 {
+            return 1;
         }
         i += 1
     }
-    return is_settable_config_key(key);
+
+    is_settable_config_key(key)
 }
+
 // deprecated
 static mut sys_config_keys: [*const libc::c_char; 3] = [
     b"sys.version\x00" as *const u8 as *const libc::c_char,
     b"sys.msgsize_max_recommended\x00" as *const u8 as *const libc::c_char,
     b"sys.config_keys\x00" as *const u8 as *const libc::c_char,
 ];
-unsafe fn get_sys_config_str(mut key: *const libc::c_char) -> *mut libc::c_char {
-    if strcmp(key, b"sys.version\x00" as *const u8 as *const libc::c_char) == 0i32 {
+
+unsafe fn get_sys_config_str(key: *const libc::c_char) -> *mut libc::c_char {
+    if strcmp(key, b"sys.version\x00" as *const u8 as *const libc::c_char) == 0 {
         return dc_strdup(VERSION as *const u8 as *const libc::c_char);
     } else if strcmp(
         key,
         b"sys.msgsize_max_recommended\x00" as *const u8 as *const libc::c_char,
-    ) == 0i32
+    ) == 0
     {
         return dc_mprintf(
             b"%i\x00" as *const u8 as *const libc::c_char,
-            24i32 * 1024i32 * 1024i32 / 4i32 * 3i32,
+            24 * 1024 * 1024 / 4 * 3,
         );
     } else if strcmp(
         key,
         b"sys.config_keys\x00" as *const u8 as *const libc::c_char,
-    ) == 0i32
+    ) == 0
     {
         return get_config_keys_str();
     } else {
         return dc_strdup(0 as *const libc::c_char);
     };
 }
+
 unsafe fn get_config_keys_str() -> *mut libc::c_char {
-    let mut ret: dc_strbuilder_t = dc_strbuilder_t {
-        buf: 0 as *mut libc::c_char,
+    let mut ret = dc_strbuilder_t {
+        buf: std::ptr::null_mut(),
         allocated: 0,
         free: 0,
-        eos: 0 as *mut libc::c_char,
+        eos: std::ptr::null_mut(),
     };
-    dc_strbuilder_init(&mut ret, 0i32);
+    dc_strbuilder_init(&mut ret, 0);
+
     let mut i = 0;
     while i
         < (::std::mem::size_of::<[*const libc::c_char; 33]>())
@@ -584,72 +526,72 @@ unsafe fn get_config_keys_str() -> *mut libc::c_char {
         dc_strbuilder_cat(&mut ret, config_keys[i as usize]);
         i += 1
     }
-    let mut i_0 = 0;
-    while i_0
+
+    let mut i = 0;
+    while i
         < (::std::mem::size_of::<[*const libc::c_char; 3]>())
             .wrapping_div(::std::mem::size_of::<*mut libc::c_char>())
     {
         if strlen(ret.buf) > 0 {
             dc_strbuilder_cat(&mut ret, b" \x00" as *const u8 as *const libc::c_char);
         }
-        dc_strbuilder_cat(&mut ret, sys_config_keys[i_0 as usize]);
-        i_0 += 1
+        dc_strbuilder_cat(&mut ret, sys_config_keys[i as usize]);
+        i += 1
     }
-    return ret.buf;
+
+    ret.buf
 }
-pub unsafe fn dc_get_info(mut context: *mut dc_context_t) -> *mut libc::c_char {
-    let mut unset: *const libc::c_char = b"0\x00" as *const u8 as *const libc::c_char;
-    let mut displayname: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut temp: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut l_readable_str: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut l2_readable_str: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut fingerprint_str: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut l: *mut dc_loginparam_t = 0 as *mut dc_loginparam_t;
-    let mut l2: *mut dc_loginparam_t = 0 as *mut dc_loginparam_t;
-    let mut inbox_watch: libc::c_int = 0i32;
-    let mut sentbox_watch: libc::c_int = 0i32;
-    let mut mvbox_watch: libc::c_int = 0i32;
-    let mut mvbox_move: libc::c_int = 0i32;
-    let mut folders_configured: libc::c_int = 0i32;
-    let mut configured_sentbox_folder: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut configured_mvbox_folder: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut contacts: libc::c_int = 0i32;
-    let mut chats: libc::c_int = 0i32;
-    let mut real_msgs: libc::c_int = 0i32;
-    let mut deaddrop_msgs: libc::c_int = 0i32;
-    let mut is_configured: libc::c_int = 0i32;
-    let mut dbversion: libc::c_int = 0i32;
-    let mut mdns_enabled: libc::c_int = 0i32;
-    let mut e2ee_enabled: libc::c_int = 0i32;
-    let mut prv_key_cnt: libc::c_int = 0i32;
-    let mut pub_key_cnt: libc::c_int = 0i32;
-    let mut self_public: *mut dc_key_t = dc_key_new();
-    let mut rpgp_enabled: libc::c_int = 0i32;
-    rpgp_enabled = 1i32;
-    let mut ret: dc_strbuilder_t = dc_strbuilder_t {
+
+pub unsafe fn dc_get_info(context: &dc_context_t) -> *mut libc::c_char {
+    let mut unset = b"0\x00" as *const u8 as *const libc::c_char;
+    let mut displayname = 0 as *mut libc::c_char;
+    let mut temp = 0 as *mut libc::c_char;
+    let mut l_readable_str = 0 as *mut libc::c_char;
+    let mut l2_readable_str = 0 as *mut libc::c_char;
+    let mut fingerprint_str = 0 as *mut libc::c_char;
+    let mut l = 0 as *mut dc_loginparam_t;
+    let mut l2 = 0 as *mut dc_loginparam_t;
+    let mut inbox_watch = 0;
+    let mut sentbox_watch = 0;
+    let mut mvbox_watch = 0;
+    let mut mvbox_move = 0;
+    let mut folders_configured = 0;
+    let mut configured_sentbox_folder = 0 as *mut libc::c_char;
+    let mut configured_mvbox_folder = 0 as *mut libc::c_char;
+    let mut contacts = 0;
+    let mut chats = 0;
+    let mut real_msgs = 0;
+    let mut deaddrop_msgs = 0;
+    let mut is_configured = 0;
+    let mut dbversion = 0;
+    let mut mdns_enabled = 0;
+    let mut e2ee_enabled = 0;
+    let mut prv_key_cnt = 0;
+    let mut pub_key_cnt = 0;
+    let mut self_public = dc_key_new();
+    let mut rpgp_enabled = 1;
+
+    let mut ret = dc_strbuilder_t {
         buf: 0 as *mut libc::c_char,
         allocated: 0,
         free: 0,
         eos: 0 as *mut libc::c_char,
     };
-    dc_strbuilder_init(&mut ret, 0i32);
-    if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
+    dc_strbuilder_init(&mut ret, 0);
+    if context.is_null() || context.magic != 0x11a11807 as libc::c_uint {
         return dc_strdup(b"ErrBadPtr\x00" as *const u8 as *const libc::c_char);
     }
+
     l = dc_loginparam_new();
     l2 = dc_loginparam_new();
-    dc_loginparam_read(
-        l,
-        (*context).sql,
-        b"\x00" as *const u8 as *const libc::c_char,
-    );
+    dc_loginparam_read(l, context.sql, b"\x00" as *const u8 as *const libc::c_char);
     dc_loginparam_read(
         l2,
-        (*context).sql,
+        context.sql,
         b"configured_\x00" as *const u8 as *const libc::c_char,
     );
     displayname = dc_sqlite3_get_config(
-        (*context).sql,
+        context.sql,
         b"displayname\x00" as *const u8 as *const libc::c_char,
         0 as *const libc::c_char,
     );
@@ -658,40 +600,40 @@ pub unsafe fn dc_get_info(mut context: *mut dc_context_t) -> *mut libc::c_char {
     deaddrop_msgs = dc_get_deaddrop_msg_cnt(context) as libc::c_int;
     contacts = dc_get_real_contact_cnt(context) as libc::c_int;
     is_configured = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"configured\x00" as *const u8 as *const libc::c_char,
-        0i32,
+        0,
     );
     dbversion = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"dbversion\x00" as *const u8 as *const libc::c_char,
-        0i32,
+        0,
     );
     e2ee_enabled = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
-        1i32,
+        1,
     );
     mdns_enabled = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
-        1i32,
+        1,
     );
     let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
-        (*context).sql,
+        context.sql,
         b"SELECT COUNT(*) FROM keypairs;\x00" as *const u8 as *const libc::c_char,
     );
     sqlite3_step(stmt);
-    prv_key_cnt = sqlite3_column_int(stmt, 0i32);
+    prv_key_cnt = sqlite3_column_int(stmt, 0);
     sqlite3_finalize(stmt);
     stmt = dc_sqlite3_prepare(
-        (*context).sql,
+        context.sql,
         b"SELECT COUNT(*) FROM acpeerstates;\x00" as *const u8 as *const libc::c_char,
     );
     sqlite3_step(stmt);
-    pub_key_cnt = sqlite3_column_int(stmt, 0i32);
+    pub_key_cnt = sqlite3_column_int(stmt, 0);
     sqlite3_finalize(stmt);
-    if 0 != dc_key_load_self_public(self_public, (*l2).addr, (*context).sql) {
+    if 0 != dc_key_load_self_public(self_public, (*l2).addr, context.sql) {
         fingerprint_str = dc_key_get_fingerprint(self_public)
     } else {
         fingerprint_str = dc_strdup(b"<Not yet calculated>\x00" as *const u8 as *const libc::c_char)
@@ -699,37 +641,37 @@ pub unsafe fn dc_get_info(mut context: *mut dc_context_t) -> *mut libc::c_char {
     l_readable_str = dc_loginparam_get_readable(l);
     l2_readable_str = dc_loginparam_get_readable(l2);
     inbox_watch = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"inbox_watch\x00" as *const u8 as *const libc::c_char,
-        1i32,
+        1,
     );
     sentbox_watch = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
-        1i32,
+        1,
     );
     mvbox_watch = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
-        1i32,
+        1,
     );
     mvbox_move = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"mvbox_move\x00" as *const u8 as *const libc::c_char,
-        1i32,
+        1,
     );
     folders_configured = dc_sqlite3_get_config_int(
-        (*context).sql,
+        context.sql,
         b"folders_configured\x00" as *const u8 as *const libc::c_char,
-        0i32,
+        0,
     );
     configured_sentbox_folder = dc_sqlite3_get_config(
-        (*context).sql,
+        context.sql,
         b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
         b"<unset>\x00" as *const u8 as *const libc::c_char,
     );
     configured_mvbox_folder = dc_sqlite3_get_config(
-        (*context).sql,
+        context.sql,
         b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
         b"<unset>\x00" as *const u8 as *const libc::c_char,
     );
@@ -783,14 +725,14 @@ pub unsafe fn dc_get_info(mut context: *mut dc_context_t) -> *mut libc::c_char {
         real_msgs,
         deaddrop_msgs,
         contacts,
-        if !(*context).dbfile.is_null() {
-            (*context).dbfile
+        if !context.dbfile.is_null() {
+            context.dbfile
         } else {
             unset
         },
         dbversion,
-        if !(*context).blobdir.is_null() {
-            (*context).blobdir
+        if !context.blobdir.is_null() {
+            context.blobdir
         } else {
             unset
         },
@@ -827,51 +769,57 @@ pub unsafe fn dc_get_info(mut context: *mut dc_context_t) -> *mut libc::c_char {
     free(configured_mvbox_folder as *mut libc::c_void);
     free(fingerprint_str as *mut libc::c_void);
     dc_key_unref(self_public);
-    return ret.buf;
+
+    ret.buf
 }
+
 pub unsafe fn dc_get_version_str() -> *mut libc::c_char {
-    return dc_strdup(VERSION as *const u8 as *const libc::c_char);
+    dc_strdup(VERSION as *const u8 as *const libc::c_char)
 }
-pub unsafe fn dc_get_fresh_msgs(mut context: *mut dc_context_t) -> *mut dc_array_t {
-    let mut show_deaddrop: libc::c_int = 0i32;
-    let mut ret: *mut dc_array_t = dc_array_new(context, 128i32 as size_t);
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || ret.is_null()) {
-        stmt =
-            dc_sqlite3_prepare((*context).sql,
-                               b"SELECT m.id FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id LEFT JOIN chats c ON m.chat_id=c.id WHERE m.state=?   AND m.hidden=0   AND m.chat_id>?   AND ct.blocked=0   AND (c.blocked=0 OR c.blocked=?) ORDER BY m.timestamp DESC,m.id DESC;\x00"
-                                   as *const u8 as *const libc::c_char);
-        sqlite3_bind_int(stmt, 1i32, 10i32);
-        sqlite3_bind_int(stmt, 2i32, 9i32);
-        sqlite3_bind_int(stmt, 3i32, if 0 != show_deaddrop { 2i32 } else { 0i32 });
-        while sqlite3_step(stmt) == 100i32 {
-            dc_array_add_id(ret, sqlite3_column_int(stmt, 0i32) as uint32_t);
+
+pub unsafe fn dc_get_fresh_msgs(context: &dc_context_t) -> *mut dc_array_t {
+    let mut show_deaddrop = 0;
+    let mut ret = dc_array_new(context, 128 as size_t);
+    let mut stmt = 0 as *mut sqlite3_stmt;
+    if !ret.is_null() {
+        stmt = dc_sqlite3_prepare(
+            context.sql,
+            b"SELECT m.id FROM msgs m LEFT JOIN contacts ct \
+              ON m.from_id=ct.id LEFT JOIN chats c ON m.chat_id=c.id WHERE m.state=?   \
+              AND m.hidden=0   \
+              AND m.chat_id>?   \
+              AND ct.blocked=0   \
+              AND (c.blocked=0 OR c.blocked=?) ORDER BY m.timestamp DESC,m.id DESC;\x00"
+                as *const u8 as *const libc::c_char,
+        );
+        sqlite3_bind_int(stmt, 1, 10);
+        sqlite3_bind_int(stmt, 2, 9);
+        sqlite3_bind_int(stmt, 3, if 0 != show_deaddrop { 2 } else { 0 });
+        while sqlite3_step(stmt) == 100 {
+            dc_array_add_id(ret, sqlite3_column_int(stmt, 0) as uint32_t);
         }
     }
     sqlite3_finalize(stmt);
-    return ret;
+    ret
 }
+
 pub unsafe fn dc_search_msgs(
-    mut context: *mut dc_context_t,
-    mut chat_id: uint32_t,
-    mut query: *const libc::c_char,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    query: *const libc::c_char,
 ) -> *mut dc_array_t {
-    //clock_t       start = clock();
-    let mut success: libc::c_int = 0i32;
-    let mut ret: *mut dc_array_t = dc_array_new(context, 100i32 as size_t);
-    let mut strLikeInText: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut strLikeBeg: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut real_query: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    if !(context.is_null()
-        || (*context).magic != 0x11a11807i32 as libc::c_uint
-        || ret.is_null()
-        || query.is_null())
-    {
+    let mut success = 0;
+    let mut ret = dc_array_new(context, 100 as size_t);
+    let mut strLikeInText = 0 as *mut libc::c_char;
+    let mut strLikeBeg = 0 as *mut libc::c_char;
+    let mut real_query = 0 as *mut libc::c_char;
+    let mut stmt = 0 as *mut sqlite3_stmt;
+
+    if !(ret.is_null() || query.is_null()) {
         real_query = dc_strdup(query);
         dc_trim(real_query);
-        if *real_query.offset(0isize) as libc::c_int == 0i32 {
-            success = 1i32
+        if *real_query.offset(0isize) as libc::c_int == 0 {
+            success = 1
         } else {
             strLikeInText = dc_mprintf(
                 b"%%%s%%\x00" as *const u8 as *const libc::c_char,
@@ -879,100 +827,106 @@ pub unsafe fn dc_search_msgs(
             );
             strLikeBeg = dc_mprintf(b"%s%%\x00" as *const u8 as *const libc::c_char, real_query);
             if 0 != chat_id {
-                stmt =
-                    dc_sqlite3_prepare((*context).sql,
-                                       b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id WHERE m.chat_id=?  AND m.hidden=0  AND ct.blocked=0 AND (txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp,m.id;\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
-                sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
-                sqlite3_bind_text(stmt, 2i32, strLikeInText, -1i32, None);
-                sqlite3_bind_text(stmt, 3i32, strLikeBeg, -1i32, None);
+                stmt = dc_sqlite3_prepare(
+                    context.sql,
+                    b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id WHERE m.chat_id=?  \
+                      AND m.hidden=0  \
+                      AND ct.blocked=0 AND (txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp,m.id;\x00"
+                        as *const u8 as *const libc::c_char
+                );
+                sqlite3_bind_int(stmt, 1, chat_id as libc::c_int);
+                sqlite3_bind_text(stmt, 2, strLikeInText, -1, None);
+                sqlite3_bind_text(stmt, 3, strLikeBeg, -1, None);
             } else {
-                let mut show_deaddrop: libc::c_int = 0i32;
-                stmt =
-                    dc_sqlite3_prepare((*context).sql,
-                                       b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id LEFT JOIN chats c ON m.chat_id=c.id WHERE m.chat_id>9 AND m.hidden=0  AND (c.blocked=0 OR c.blocked=?) AND ct.blocked=0 AND (m.txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp DESC,m.id DESC;\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
-                sqlite3_bind_int(stmt, 1i32, if 0 != show_deaddrop { 2i32 } else { 0i32 });
-                sqlite3_bind_text(stmt, 2i32, strLikeInText, -1i32, None);
-                sqlite3_bind_text(stmt, 3i32, strLikeBeg, -1i32, None);
+                let mut show_deaddrop = 0;
+                stmt = dc_sqlite3_prepare(
+                    context.sql,
+                    b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id \
+                      LEFT JOIN chats c ON m.chat_id=c.id WHERE m.chat_id>9 AND m.hidden=0  \
+                      AND (c.blocked=0 OR c.blocked=?) \
+                      AND ct.blocked=0 AND (m.txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp DESC,m.id DESC;\x00"
+                        as *const u8 as *const libc::c_char
+                );
+                sqlite3_bind_int(stmt, 1, if 0 != show_deaddrop { 2 } else { 0 });
+                sqlite3_bind_text(stmt, 2, strLikeInText, -1, None);
+                sqlite3_bind_text(stmt, 3, strLikeBeg, -1, None);
             }
-            while sqlite3_step(stmt) == 100i32 {
-                dc_array_add_id(ret, sqlite3_column_int(stmt, 0i32) as uint32_t);
+            while sqlite3_step(stmt) == 100 {
+                dc_array_add_id(ret, sqlite3_column_int(stmt, 0) as uint32_t);
             }
-            success = 1i32
+            success = 1
         }
     }
+
     free(strLikeInText as *mut libc::c_void);
     free(strLikeBeg as *mut libc::c_void);
     free(real_query as *mut libc::c_void);
     sqlite3_finalize(stmt);
+
     if 0 != success {
-        return ret;
+        ret
     } else {
         if !ret.is_null() {
             dc_array_unref(ret);
         }
-        return 0 as *mut dc_array_t;
-    };
+        0 as *mut dc_array_t
+    }
 }
 
 pub unsafe fn dc_is_inbox(
-    _context: *mut dc_context_t,
+    _context: &dc_context_t,
     folder_name: *const libc::c_char,
 ) -> libc::c_int {
-    let mut is_inbox: libc::c_int = 0i32;
+    let mut is_inbox = 0;
     if !folder_name.is_null() {
         is_inbox = if strcasecmp(
             b"INBOX\x00" as *const u8 as *const libc::c_char,
             folder_name,
-        ) == 0i32
+        ) == 0
         {
-            1i32
+            1
         } else {
-            0i32
+            0
         }
     }
-    return is_inbox;
+    is_inbox
 }
+
 pub unsafe fn dc_is_sentbox(
-    mut context: *mut dc_context_t,
-    mut folder_name: *const libc::c_char,
+    context: &dc_context_t,
+    folder_name: *const libc::c_char,
 ) -> libc::c_int {
-    let mut sentbox_name: *mut libc::c_char = dc_sqlite3_get_config(
-        (*context).sql,
+    let mut sentbox_name = dc_sqlite3_get_config(
+        context.sql,
         b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
         0 as *const libc::c_char,
     );
-    let mut is_sentbox: libc::c_int = 0i32;
+    let mut is_sentbox = 0;
     if !sentbox_name.is_null() && !folder_name.is_null() {
-        is_sentbox = if strcasecmp(sentbox_name, folder_name) == 0i32 {
-            1i32
+        is_sentbox = if strcasecmp(sentbox_name, folder_name) == 0 {
+            1
         } else {
-            0i32
+            0
         }
     }
     free(sentbox_name as *mut libc::c_void);
-    return is_sentbox;
+    is_sentbox
 }
-pub unsafe fn dc_is_mvbox(
-    mut context: *mut dc_context_t,
-    mut folder_name: *const libc::c_char,
-) -> libc::c_int {
-    let mut mvbox_name: *mut libc::c_char = dc_sqlite3_get_config(
-        (*context).sql,
+
+pub unsafe fn dc_is_mvbox(context: &dc_context_t, folder_name: *const libc::c_char) -> libc::c_int {
+    let mut mvbox_name = dc_sqlite3_get_config(
+        context.sql,
         b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
         0 as *const libc::c_char,
     );
-    let mut is_mvbox: libc::c_int = 0i32;
+    let mut is_mvbox = 0;
     if !mvbox_name.is_null() && !folder_name.is_null() {
-        is_mvbox = if strcasecmp(mvbox_name, folder_name) == 0i32 {
-            1i32
+        is_mvbox = if strcasecmp(mvbox_name, folder_name) == 0 {
+            1
         } else {
-            0i32
+            0
         }
     }
     free(mvbox_name as *mut libc::c_void);
-    return is_mvbox;
+    is_mvbox
 }
diff --git a/src/dc_e2ee.rs b/src/dc_e2ee.rs
index e0a80fa0b..93cb77061 100644
--- a/src/dc_e2ee.rs
+++ b/src/dc_e2ee.rs
@@ -527,17 +527,6 @@ unsafe fn load_or_generate_self_public_key(
             } else {
                 key_creation_here = 1i32;
                 s_in_key_creation = 1i32;
-                /* seed the random generator */
-                let mut seed: [uintptr_t; 4] = [0; 4];
-                seed[0usize] = time(0 as *mut time_t) as uintptr_t;
-                seed[1usize] = seed.as_mut_ptr() as uintptr_t;
-                seed[2usize] = public_key as uintptr_t;
-                seed[3usize] = pthread_self() as uintptr_t;
-                dc_pgp_rand_seed(
-                    context,
-                    seed.as_mut_ptr() as *const libc::c_void,
-                    ::std::mem::size_of::<[uintptr_t; 4]>(),
-                );
                 if !random_data_mime.is_null() {
                     let mut random_data_mmap: *mut MMAPString = 0 as *mut MMAPString;
                     let mut col: libc::c_int = 0i32;
@@ -546,11 +535,6 @@ unsafe fn load_or_generate_self_public_key(
                         current_block = 10496152961502316708;
                     } else {
                         mailmime_write_mem(random_data_mmap, &mut col, random_data_mime);
-                        dc_pgp_rand_seed(
-                            context,
-                            (*random_data_mmap).str_0 as *const libc::c_void,
-                            (*random_data_mmap).len,
-                        );
                         mmap_string_free(random_data_mmap);
                         current_block = 26972500619410423;
                     }
diff --git a/src/dc_imap.rs b/src/dc_imap.rs
index caf40429f..e122185a2 100644
--- a/src/dc_imap.rs
+++ b/src/dc_imap.rs
@@ -1,4 +1,5 @@
 use libc;
+use std::sync::{Condvar, Mutex};
 
 use crate::constants::Event;
 use crate::dc_context::dc_context_t;
@@ -11,28 +12,25 @@ use crate::dc_tools::*;
 use crate::types::*;
 use crate::x::*;
 
-#[derive(Copy, Clone)]
 #[repr(C)]
 pub struct dc_imap_t {
     pub addr: *mut libc::c_char,
     pub imap_server: *mut libc::c_char,
-    pub imap_port: libc::c_int,
+    pub imap_port: i32,
     pub imap_user: *mut libc::c_char,
     pub imap_pw: *mut libc::c_char,
-    pub server_flags: libc::c_int,
-    pub connected: libc::c_int,
+    pub server_flags: i32,
+    pub connected: i32,
     pub etpan: *mut mailimap,
-    pub idle_set_up: libc::c_int,
+    pub idle_set_up: i32,
     pub selected_folder: *mut libc::c_char,
-    pub selected_folder_needs_expunge: libc::c_int,
-    pub should_reconnect: libc::c_int,
-    pub can_idle: libc::c_int,
-    pub has_xlist: libc::c_int,
+    pub selected_folder_needs_expunge: i32,
+    pub should_reconnect: i32,
+    pub can_idle: i32,
+    pub has_xlist: i32,
     pub imap_delimiter: libc::c_char,
     pub watch_folder: *mut libc::c_char,
-    pub watch_cond: pthread_cond_t,
-    pub watch_condmutex: pthread_mutex_t,
-    pub watch_condflag: libc::c_int,
+    pub watch: (Mutex<bool>, Condvar),
     pub fetch_type_prefetch: *mut mailimap_fetch_type,
     pub fetch_type_body: *mut mailimap_fetch_type,
     pub fetch_type_flags: *mut mailimap_fetch_type,
@@ -40,66 +38,75 @@ pub struct dc_imap_t {
     pub set_config: dc_set_config_t,
     pub precheck_imf: dc_precheck_imf_t,
     pub receive_imf: dc_receive_imf_t,
-    pub userData: *mut libc::c_void,
+    // TODO: remove
     pub context: *mut dc_context_t,
-    pub log_connect_errors: libc::c_int,
-    pub skip_log_capabilities: libc::c_int,
+    pub log_connect_errors: i32,
+    pub skip_log_capabilities: i32,
 }
 
 pub unsafe fn dc_imap_new(
-    mut get_config: dc_get_config_t,
-    mut set_config: dc_set_config_t,
-    mut precheck_imf: dc_precheck_imf_t,
-    mut receive_imf: dc_receive_imf_t,
-    mut userData: *mut libc::c_void,
-    mut context: *mut dc_context_t,
-) -> *mut dc_imap_t {
-    let mut imap: *mut dc_imap_t = 0 as *mut dc_imap_t;
-    imap = calloc(1, ::std::mem::size_of::<dc_imap_t>()) as *mut dc_imap_t;
-    if imap.is_null() {
-        exit(25i32);
-    }
-    (*imap).log_connect_errors = 1i32;
-    (*imap).context = context;
-    (*imap).get_config = get_config;
-    (*imap).set_config = set_config;
-    (*imap).precheck_imf = precheck_imf;
-    (*imap).receive_imf = receive_imf;
-    (*imap).userData = userData;
-    pthread_mutex_init(
-        &mut (*imap).watch_condmutex,
-        0 as *const pthread_mutexattr_t,
-    );
-    pthread_cond_init(&mut (*imap).watch_cond, 0 as *const pthread_condattr_t);
-    (*imap).watch_folder = calloc(1, 1) as *mut libc::c_char;
-    (*imap).selected_folder = calloc(1, 1) as *mut libc::c_char;
-    (*imap).fetch_type_prefetch = mailimap_fetch_type_new_fetch_att_list_empty();
+    get_config: dc_get_config_t,
+    set_config: dc_set_config_t,
+    precheck_imf: dc_precheck_imf_t,
+    receive_imf: dc_receive_imf_t,
+) -> dc_imap_t {
+    let mut imap = dc_imap_t {
+        addr: std::ptr::null_mut(),
+        imap_server: std::ptr::null_mut(),
+        imap_port: 0,
+        imap_user: std::ptr::null_mut(),
+        imap_pw: std::ptr::null_mut(),
+        server_flags: 0,
+        connected: 0,
+        etpan: std::ptr::null_mut(),
+        idle_set_up: 0,
+        selected_folder: calloc(1, 1) as *mut libc::c_char,
+        selected_folder_needs_expunge: 0,
+        should_reconnect: 0,
+        can_idle: 0,
+        has_xlist: 0,
+        imap_delimiter: 0 as libc::c_char,
+        watch_folder: calloc(1, 1) as *mut libc::c_char,
+        watch: (Mutex::new(false), Condvar::new()),
+        fetch_type_prefetch: mailimap_fetch_type_new_fetch_att_list_empty(),
+        fetch_type_body: mailimap_fetch_type_new_fetch_att_list_empty(),
+        fetch_type_flags: mailimap_fetch_type_new_fetch_att_list_empty(),
+        get_config,
+        set_config,
+        precheck_imf,
+        receive_imf,
+        // TODO: remove
+        context: std::ptr::null_mut(),
+        log_connect_errors: 1,
+        skip_log_capabilities: 0,
+    };
     mailimap_fetch_type_new_fetch_att_list_add(
-        (*imap).fetch_type_prefetch,
+        imap.fetch_type_prefetch,
         mailimap_fetch_att_new_uid(),
     );
     mailimap_fetch_type_new_fetch_att_list_add(
-        (*imap).fetch_type_prefetch,
+        imap.fetch_type_prefetch,
         mailimap_fetch_att_new_envelope(),
     );
-    (*imap).fetch_type_body = mailimap_fetch_type_new_fetch_att_list_empty();
+
     mailimap_fetch_type_new_fetch_att_list_add(
-        (*imap).fetch_type_body,
+        imap.fetch_type_body,
         mailimap_fetch_att_new_flags(),
     );
     mailimap_fetch_type_new_fetch_att_list_add(
-        (*imap).fetch_type_body,
+        imap.fetch_type_body,
         mailimap_fetch_att_new_body_peek_section(mailimap_section_new(
             0 as *mut mailimap_section_spec,
         )),
     );
-    (*imap).fetch_type_flags = mailimap_fetch_type_new_fetch_att_list_empty();
     mailimap_fetch_type_new_fetch_att_list_add(
         (*imap).fetch_type_flags,
         mailimap_fetch_att_new_flags(),
     );
-    return imap;
+
+    imap
 }
+
 pub unsafe fn dc_imap_unref(mut imap: *mut dc_imap_t) {
     if imap.is_null() {
         return;
diff --git a/src/dc_job.rs b/src/dc_job.rs
index b88ae293e..89e20f239 100644
--- a/src/dc_job.rs
+++ b/src/dc_job.rs
@@ -51,11 +51,13 @@ pub unsafe fn dc_perform_imap_jobs(mut context: *mut dc_context_t) {
         0i32,
         b"INBOX-jobs started...\x00" as *const u8 as *const libc::c_char,
     );
-    pthread_mutex_lock(&mut (*context).inboxidle_condmutex);
+
+    let l = (*context).inboxidle_condmutex.lock().unwrap();
     let mut probe_imap_network: libc::c_int = (*context).probe_imap_network;
     (*context).probe_imap_network = 0i32;
     (*context).perform_inbox_jobs_needed = 0i32;
-    pthread_mutex_unlock(&mut (*context).inboxidle_condmutex);
+    drop(l);
+
     dc_job_perform(context, 100i32, probe_imap_network);
     dc_log_info(
         context,
@@ -934,9 +936,9 @@ pub unsafe fn dc_interrupt_imap_idle(mut context: *mut dc_context_t) {
         0i32,
         b"Interrupting IMAP-IDLE...\x00" as *const u8 as *const libc::c_char,
     );
-    pthread_mutex_lock(&mut (*context).inboxidle_condmutex);
+    let l = (*context).inboxidle_condmutex.lock().unwrap();
     (*context).perform_inbox_jobs_needed = 1i32;
-    pthread_mutex_unlock(&mut (*context).inboxidle_condmutex);
+    drop(l);
     dc_imap_interrupt_idle((*context).inbox);
 }
 unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(
@@ -1058,7 +1060,7 @@ pub unsafe fn dc_perform_imap_idle(mut context: *mut dc_context_t) {
         return;
     }
     connect_to_inbox(context);
-    pthread_mutex_lock(&mut (*context).inboxidle_condmutex);
+    let l = (*context).inboxidle_condmutex.lock().unwrap();
     if 0 != (*context).perform_inbox_jobs_needed {
         dc_log_info(
             context,
@@ -1066,10 +1068,10 @@ pub unsafe fn dc_perform_imap_idle(mut context: *mut dc_context_t) {
             b"INBOX-IDLE will not be started because of waiting jobs.\x00" as *const u8
                 as *const libc::c_char,
         );
-        pthread_mutex_unlock(&mut (*context).inboxidle_condmutex);
+        drop(l);
         return;
     }
-    pthread_mutex_unlock(&mut (*context).inboxidle_condmutex);
+    drop(l);
     dc_log_info(
         context,
         0i32,
@@ -1251,9 +1253,9 @@ pub unsafe fn dc_maybe_network(mut context: *mut dc_context_t) {
     pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
     (*context).probe_smtp_network = 1i32;
     pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
-    pthread_mutex_lock(&mut (*context).inboxidle_condmutex);
+    let l = (*context).inboxidle_condmutex.lock().unwrap();
     (*context).probe_imap_network = 1i32;
-    pthread_mutex_unlock(&mut (*context).inboxidle_condmutex);
+    drop(l);
     dc_interrupt_smtp_idle(context);
     dc_interrupt_imap_idle(context);
     dc_interrupt_mvbox_idle(context);
diff --git a/src/dc_jobthread.rs b/src/dc_jobthread.rs
index 9182fc28a..e9faa7a69 100644
--- a/src/dc_jobthread.rs
+++ b/src/dc_jobthread.rs
@@ -1,3 +1,5 @@
+use std::sync::{Condvar, Mutex};
+
 use libc;
 
 use crate::dc_configure::*;
@@ -10,52 +12,47 @@ use crate::dc_tools::*;
 use crate::types::*;
 use crate::x::*;
 
-#[derive(Copy, Clone)]
 #[repr(C)]
 pub struct dc_jobthread_t {
+    // TODO: remove
     pub context: *mut dc_context_t,
     pub name: *mut libc::c_char,
     pub folder_config_name: *mut libc::c_char,
     pub imap: *mut dc_imap_t,
-    pub mutex: pthread_mutex_t,
-    pub idle_cond: pthread_cond_t,
-    pub idle_condflag: libc::c_int,
+    pub idle: (Mutex<bool>, Condvar),
     pub jobs_needed: libc::c_int,
     pub suspended: libc::c_int,
     pub using_handle: libc::c_int,
 }
 
 pub unsafe fn dc_jobthread_init(
-    mut jobthread: *mut dc_jobthread_t,
-    mut context: *mut dc_context_t,
-    mut name: *const libc::c_char,
-    mut folder_config_name: *const libc::c_char,
-) {
-    if jobthread.is_null() || context.is_null() || name.is_null() {
-        return;
+    name: *const libc::c_char,
+    folder_config_name: *const libc::c_char,
+    imap: *mut dc_imap_t,
+) -> dc_jobthread_t {
+    dc_jobthread_t {
+        context: std::ptr::null_mut(),
+        name: dc_strdup(name),
+        folder_config_name: dc_strdup(folder_config_name),
+        imap,
+        idle: (Mutex::new(false), Condvar::new()),
+        jobs_needed: 0i32,
+        suspended: 0i32,
+        using_handle: 0i32,
     }
-    (*jobthread).context = context;
-    (*jobthread).name = dc_strdup(name);
-    (*jobthread).folder_config_name = dc_strdup(folder_config_name);
-    (*jobthread).imap = 0 as *mut dc_imap_t;
-    pthread_mutex_init(&mut (*jobthread).mutex, 0 as *const pthread_mutexattr_t);
-    pthread_cond_init(&mut (*jobthread).idle_cond, 0 as *const pthread_condattr_t);
-    (*jobthread).idle_condflag = 0i32;
-    (*jobthread).jobs_needed = 0i32;
-    (*jobthread).suspended = 0i32;
-    (*jobthread).using_handle = 0i32;
 }
+
 pub unsafe fn dc_jobthread_exit(mut jobthread: *mut dc_jobthread_t) {
     if jobthread.is_null() {
         return;
     }
-    pthread_cond_destroy(&mut (*jobthread).idle_cond);
-    pthread_mutex_destroy(&mut (*jobthread).mutex);
+
     free((*jobthread).name as *mut libc::c_void);
     (*jobthread).name = 0 as *mut libc::c_char;
     free((*jobthread).folder_config_name as *mut libc::c_void);
     (*jobthread).folder_config_name = 0 as *mut libc::c_char;
 }
+
 pub unsafe fn dc_jobthread_suspend(mut jobthread: *mut dc_jobthread_t, mut suspend: libc::c_int) {
     if jobthread.is_null() {
         return;
diff --git a/src/dc_pgp.rs b/src/dc_pgp.rs
index 15c62234a..899f816d9 100644
--- a/src/dc_pgp.rs
+++ b/src/dc_pgp.rs
@@ -10,17 +10,7 @@ use crate::pgp as rpgp;
 use crate::types::*;
 use crate::x::*;
 
-/* ** library-private **********************************************************/
-/* validation errors */
-/* misc. */
-pub unsafe fn dc_pgp_init() {}
 pub unsafe fn dc_pgp_exit() {}
-pub unsafe fn dc_pgp_rand_seed(
-    _context: *mut dc_context_t,
-    _buf: *const libc::c_void,
-    _bytes: size_t,
-) {
-}
 
 pub unsafe fn dc_split_armored_data(
     mut buf: *mut libc::c_char,
diff --git a/src/dc_receive_imf.rs b/src/dc_receive_imf.rs
index 529df8ae7..b4c2c919a 100644
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -25,12 +25,12 @@ use crate::types::*;
 use crate::x::*;
 
 pub unsafe fn dc_receive_imf(
-    mut context: *mut dc_context_t,
-    mut imf_raw_not_terminated: *const libc::c_char,
-    mut imf_raw_bytes: size_t,
-    mut server_folder: *const libc::c_char,
-    mut server_uid: uint32_t,
-    mut flags: uint32_t,
+    context: &dc_context_t,
+    imf_raw_not_terminated: *const libc::c_char,
+    imf_raw_bytes: size_t,
+    server_folder: *const libc::c_char,
+    server_uid: uint32_t,
+    flags: uint32_t,
 ) {
     let mut current_block: u64;
     /* the function returns the number of created messages in the database */
diff --git a/src/dc_smtp.rs b/src/dc_smtp.rs
index c91fdae76..11566ee32 100644
--- a/src/dc_smtp.rs
+++ b/src/dc_smtp.rs
@@ -16,21 +16,24 @@ pub struct dc_smtp_t {
     pub from: *mut libc::c_char,
     pub esmtp: libc::c_int,
     pub log_connect_errors: libc::c_int,
+    // TODO: Remvoe
     pub context: *mut dc_context_t,
     pub error: *mut libc::c_char,
     pub error_etpan: libc::c_int,
 }
 
-pub unsafe fn dc_smtp_new(mut context: *mut dc_context_t) -> *mut dc_smtp_t {
-    let mut smtp: *mut dc_smtp_t = 0 as *mut dc_smtp_t;
-    smtp = calloc(1, ::std::mem::size_of::<dc_smtp_t>()) as *mut dc_smtp_t;
-    if smtp.is_null() {
-        exit(29i32);
+pub fn dc_smtp_new() -> dc_smtp_t {
+    dc_smtp_t {
+        etpan: std::ptr::null_mut(),
+        from: std::ptr::null_mut(),
+        esmtp: 0,
+        log_connect_errors: 1,
+        context: std::ptr::null_mut(),
+        error: std::ptr::null_mut(),
+        error_etpan: 0,
     }
-    (*smtp).log_connect_errors = 1i32;
-    (*smtp).context = context;
-    return smtp;
 }
+
 pub unsafe fn dc_smtp_unref(mut smtp: *mut dc_smtp_t) {
     if smtp.is_null() {
         return;
diff --git a/src/dc_sqlite3.rs b/src/dc_sqlite3.rs
index 0c53c1d01..b49905999 100644
--- a/src/dc_sqlite3.rs
+++ b/src/dc_sqlite3.rs
@@ -1,5 +1,6 @@
 use libc;
 
+use crate::constants::*;
 use crate::dc_apeerstate::*;
 use crate::dc_context::dc_context_t;
 use crate::dc_hash::*;
@@ -9,86 +10,78 @@ use crate::dc_tools::*;
 use crate::types::*;
 use crate::x::*;
 
-/* *
- * Library-internal.
- */
-#[derive(Copy, Clone)]
+/// A simple wrapper around the underlying Sqlite3 object.
 #[repr(C)]
 pub struct dc_sqlite3_t {
     pub cobj: *mut sqlite3,
-    pub context: *mut dc_context_t,
 }
 
-pub unsafe fn dc_sqlite3_new(mut context: *mut dc_context_t) -> *mut dc_sqlite3_t {
-    let mut sql: *mut dc_sqlite3_t = 0 as *mut dc_sqlite3_t;
-    sql = calloc(1, ::std::mem::size_of::<dc_sqlite3_t>()) as *mut dc_sqlite3_t;
-    if sql.is_null() {
-        exit(24i32);
+pub fn dc_sqlite3_new() -> dc_sqlite3_t {
+    dc_sqlite3_t {
+        cobj: std::ptr::null_mut(),
     }
-    (*sql).context = context;
-    return sql;
 }
-pub unsafe fn dc_sqlite3_unref(mut sql: *mut dc_sqlite3_t) {
-    if sql.is_null() {
-        return;
+
+pub unsafe fn dc_sqlite3_unref(context: &dc_context_t, sql: &mut dc_sqlite3_t) {
+    if !sql.cobj.is_null() {
+        dc_sqlite3_close(context, sql);
     }
-    if !(*sql).cobj.is_null() {
-        dc_sqlite3_close(sql);
-    }
-    free(sql as *mut libc::c_void);
 }
-pub unsafe fn dc_sqlite3_close(mut sql: *mut dc_sqlite3_t) {
-    if sql.is_null() {
-        return;
-    }
-    if !(*sql).cobj.is_null() {
-        sqlite3_close((*sql).cobj);
-        (*sql).cobj = 0 as *mut sqlite3
+
+pub unsafe fn dc_sqlite3_close(context: &dc_context_t, sql: &mut dc_sqlite3_t) {
+    if !sql.cobj.is_null() {
+        sqlite3_close(sql.cobj);
+        sql.cobj = 0 as *mut sqlite3
     }
+
     dc_log_info(
-        (*sql).context,
-        0i32,
+        context,
+        0,
         b"Database closed.\x00" as *const u8 as *const libc::c_char,
     );
 }
+
 pub unsafe fn dc_sqlite3_open(
-    mut sql: *mut dc_sqlite3_t,
-    mut dbfile: *const libc::c_char,
-    mut flags: libc::c_int,
+    context: &context,
+    sql: &mut dc_sqlite3_t,
+    dbfile: *const libc::c_char,
+    flags: libc::c_int,
 ) -> libc::c_int {
     let mut current_block: u64;
     if 0 != dc_sqlite3_is_open(sql) {
-        return 0i32;
+        return 0;
     }
-    if !(sql.is_null() || dbfile.is_null()) {
-        if sqlite3_threadsafe() == 0i32 {
+    if !dbfile.is_null() {
+        if sqlite3_threadsafe() == 0 {
             dc_log_error(
-                (*sql).context,
-                0i32,
+                context,
+                0,
                 b"Sqlite3 compiled thread-unsafe; this is not supported.\x00" as *const u8
                     as *const libc::c_char,
             );
-        } else if !(*sql).cobj.is_null() {
+        } else if !sql.cobj.is_null() {
             dc_log_error(
-                (*sql).context,
-                0i32,
+                context,
+                0,
                 b"Cannot open, database \"%s\" already opened.\x00" as *const u8
                     as *const libc::c_char,
                 dbfile,
             );
         } else if sqlite3_open_v2(
             dbfile,
-            &mut (*sql).cobj,
-            0x10000i32
-                | if 0 != flags & 0x1i32 {
-                    0x1i32
+            &mut sql.cobj,
+            SQLITE_OPEN_FULLMUTEX
+                | (if (flags & DC_OPEN_READONLY) {
+                    SQLITE_OPEN_READONLY
                 } else {
-                    0x2i32 | 0x4i32
-                },
+                    SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
+                }),
+            std::ptr::null(),
             0 as *const libc::c_char,
-        ) != 0i32
+        ) != 0
         {
             dc_sqlite3_log_error(
+                context,
                 sql,
                 b"Cannot open database \"%s\".\x00" as *const u8 as *const libc::c_char,
                 dbfile,
@@ -98,35 +91,45 @@ pub unsafe fn dc_sqlite3_open(
                 sql,
                 b"PRAGMA secure_delete=on;\x00" as *const u8 as *const libc::c_char,
             );
-            sqlite3_busy_timeout((*sql).cobj, 10i32 * 1000i32);
-            if 0 == flags & 0x1i32 {
-                let mut exists_before_update: libc::c_int = 0i32;
-                let mut dbversion_before_update: libc::c_int = 0i32;
+            sqlite3_busy_timeout(sql.cobj, 10 * 1000);
+            if 0 == flags & DC_OPEN_READONLY {
+                let mut exists_before_update = 0;
+                let mut dbversion_before_update = 0;
                 /* Init tables to dbversion=0 */
                 if 0 == dc_sqlite3_table_exists(
                     sql,
                     b"config\x00" as *const u8 as *const libc::c_char,
                 ) {
                     dc_log_info(
-                        (*sql).context,
-                        0i32,
+                        context,
+                        0,
                         b"First time init: creating tables in \"%s\".\x00" as *const u8
                             as *const libc::c_char,
                         dbfile,
                     );
-                    dc_sqlite3_execute(sql,
-                                       b"CREATE TABLE config (id INTEGER PRIMARY KEY, keyname TEXT, value TEXT);\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
+                    dc_sqlite3_execute(
+                        sql,
+                        b"CREATE TABLE config (id INTEGER PRIMARY KEY, keyname TEXT, value TEXT);\x00"
+                            as *const u8 as
+                            *const libc::c_char
+                    );
                     dc_sqlite3_execute(
                         sql,
                         b"CREATE INDEX config_index1 ON config (keyname);\x00" as *const u8
                             as *const libc::c_char,
                     );
-                    dc_sqlite3_execute(sql,
-                                       b"CREATE TABLE contacts (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT DEFAULT \'\', addr TEXT DEFAULT \'\' COLLATE NOCASE, origin INTEGER DEFAULT 0, blocked INTEGER DEFAULT 0, last_seen INTEGER DEFAULT 0, param TEXT DEFAULT \'\');\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
+                    dc_sqlite3_execute(
+                        sql,
+                        b"CREATE TABLE contacts (\
+                          id INTEGER PRIMARY KEY AUTOINCREMENT, \
+                          name TEXT DEFAULT \'\', \
+                          addr TEXT DEFAULT \'\' COLLATE NOCASE, \
+                          origin INTEGER DEFAULT 0, \
+                          blocked INTEGER DEFAULT 0, \
+                          last_seen INTEGER DEFAULT 0, \
+                          param TEXT DEFAULT \'\');\x00" as *const u8
+                            as *const libc::c_char,
+                    );
                     dc_sqlite3_execute(
                         sql,
                         b"CREATE INDEX contacts_index1 ON contacts (name COLLATE NOCASE);\x00"
@@ -137,14 +140,27 @@ pub unsafe fn dc_sqlite3_open(
                         b"CREATE INDEX contacts_index2 ON contacts (addr COLLATE NOCASE);\x00"
                             as *const u8 as *const libc::c_char,
                     );
-                    dc_sqlite3_execute(sql,
-                                       b"INSERT INTO contacts (id,name,origin) VALUES (1,\'self\',262144), (2,\'device\',262144), (3,\'rsvd\',262144), (4,\'rsvd\',262144), (5,\'rsvd\',262144), (6,\'rsvd\',262144), (7,\'rsvd\',262144), (8,\'rsvd\',262144), (9,\'rsvd\',262144);\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
-                    dc_sqlite3_execute(sql,
-                                       b"CREATE TABLE chats (id INTEGER PRIMARY KEY AUTOINCREMENT,  type INTEGER DEFAULT 0, name TEXT DEFAULT \'\', draft_timestamp INTEGER DEFAULT 0, draft_txt TEXT DEFAULT \'\', blocked INTEGER DEFAULT 0, grpid TEXT DEFAULT \'\', param TEXT DEFAULT \'\');\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
+                    dc_sqlite3_execute(
+                        sql,
+                        b"INSERT INTO contacts (id,name,origin) VALUES \
+                          (1,\'self\',262144), (2,\'device\',262144), (3,\'rsvd\',262144), \
+                          (4,\'rsvd\',262144), (5,\'rsvd\',262144), (6,\'rsvd\',262144), \
+                          (7,\'rsvd\',262144), (8,\'rsvd\',262144), (9,\'rsvd\',262144);\x00"
+                            as *const u8 as *const libc::c_char,
+                    );
+                    dc_sqlite3_execute(
+                        sql,
+                        b"CREATE TABLE chats (\
+                          id INTEGER PRIMARY KEY AUTOINCREMENT,  \
+                          type INTEGER DEFAULT 0, \
+                          name TEXT DEFAULT \'\', \
+                          draft_timestamp INTEGER DEFAULT 0, \
+                          draft_txt TEXT DEFAULT \'\', \
+                          blocked INTEGER DEFAULT 0, \
+                          grpid TEXT DEFAULT \'\', \
+                          param TEXT DEFAULT \'\');\x00" as *const u8
+                            as *const libc::c_char,
+                    );
                     dc_sqlite3_execute(
                         sql,
                         b"CREATE INDEX chats_index1 ON chats (grpid);\x00" as *const u8
@@ -160,14 +176,34 @@ pub unsafe fn dc_sqlite3_open(
                         b"CREATE INDEX chats_contacts_index1 ON chats_contacts (chat_id);\x00"
                             as *const u8 as *const libc::c_char,
                     );
-                    dc_sqlite3_execute(sql,
-                                       b"INSERT INTO chats (id,type,name) VALUES (1,120,\'deaddrop\'), (2,120,\'rsvd\'), (3,120,\'trash\'), (4,120,\'msgs_in_creation\'), (5,120,\'starred\'), (6,120,\'archivedlink\'), (7,100,\'rsvd\'), (8,100,\'rsvd\'), (9,100,\'rsvd\');\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
-                    dc_sqlite3_execute(sql,
-                                       b"CREATE TABLE msgs (id INTEGER PRIMARY KEY AUTOINCREMENT, rfc724_mid TEXT DEFAULT \'\', server_folder TEXT DEFAULT \'\', server_uid INTEGER DEFAULT 0, chat_id INTEGER DEFAULT 0, from_id INTEGER DEFAULT 0, to_id INTEGER DEFAULT 0, timestamp INTEGER DEFAULT 0, type INTEGER DEFAULT 0, state INTEGER DEFAULT 0, msgrmsg INTEGER DEFAULT 1, bytes INTEGER DEFAULT 0, txt TEXT DEFAULT \'\', txt_raw TEXT DEFAULT \'\', param TEXT DEFAULT \'\');\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
+                    dc_sqlite3_execute(
+                        sql,
+                        b"INSERT INTO chats (id,type,name) VALUES \
+                          (1,120,\'deaddrop\'), (2,120,\'rsvd\'), (3,120,\'trash\'), \
+                          (4,120,\'msgs_in_creation\'), (5,120,\'starred\'), (6,120,\'archivedlink\'), \
+                          (7,100,\'rsvd\'), (8,100,\'rsvd\'), (9,100,\'rsvd\');\x00"
+                            as *const u8 as *const libc::c_char
+                    );
+                    dc_sqlite3_execute(
+                        sql,
+                        b"CREATE TABLE msgs (\
+                          id INTEGER PRIMARY KEY AUTOINCREMENT, \
+                          rfc724_mid TEXT DEFAULT \'\', \
+                          server_folder TEXT DEFAULT \'\', \
+                          server_uid INTEGER DEFAULT 0, \
+                          chat_id INTEGER DEFAULT 0, \
+                          from_id INTEGER DEFAULT 0, \
+                          to_id INTEGER DEFAULT 0, \
+                          timestamp INTEGER DEFAULT 0, \
+                          type INTEGER DEFAULT 0, \
+                          state INTEGER DEFAULT 0, \
+                          msgrmsg INTEGER DEFAULT 1, \
+                          bytes INTEGER DEFAULT 0, \
+                          txt TEXT DEFAULT \'\', \
+                          txt_raw TEXT DEFAULT \'\', \
+                          param TEXT DEFAULT \'\');\x00" as *const u8
+                            as *const libc::c_char,
+                    );
                     dc_sqlite3_execute(
                         sql,
                         b"CREATE INDEX msgs_index1 ON msgs (rfc724_mid);\x00" as *const u8
@@ -188,14 +224,25 @@ pub unsafe fn dc_sqlite3_open(
                         b"CREATE INDEX msgs_index4 ON msgs (state);\x00" as *const u8
                             as *const libc::c_char,
                     );
-                    dc_sqlite3_execute(sql,
-                                       b"INSERT INTO msgs (id,msgrmsg,txt) VALUES (1,0,\'marker1\'), (2,0,\'rsvd\'), (3,0,\'rsvd\'), (4,0,\'rsvd\'), (5,0,\'rsvd\'), (6,0,\'rsvd\'), (7,0,\'rsvd\'), (8,0,\'rsvd\'), (9,0,\'daymarker\');\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
-                    dc_sqlite3_execute(sql,
-                                       b"CREATE TABLE jobs (id INTEGER PRIMARY KEY AUTOINCREMENT, added_timestamp INTEGER, desired_timestamp INTEGER DEFAULT 0, action INTEGER, foreign_id INTEGER, param TEXT DEFAULT \'\');\x00"
-                                           as *const u8 as
-                                           *const libc::c_char);
+                    dc_sqlite3_execute(
+                        sql,
+                        b"INSERT INTO msgs (id,msgrmsg,txt) VALUES \
+                          (1,0,\'marker1\'), (2,0,\'rsvd\'), (3,0,\'rsvd\'), \
+                          (4,0,\'rsvd\'), (5,0,\'rsvd\'), (6,0,\'rsvd\'), (7,0,\'rsvd\'), \
+                          (8,0,\'rsvd\'), (9,0,\'daymarker\');\x00"
+                            as *const u8 as *const libc::c_char,
+                    );
+                    dc_sqlite3_execute(
+                        sql,
+                        b"CREATE TABLE jobs (\
+                          id INTEGER PRIMARY KEY AUTOINCREMENT, \
+                          added_timestamp INTEGER, \
+                          desired_timestamp INTEGER DEFAULT 0, \
+                          action INTEGER, \
+                          foreign_id INTEGER, \
+                          param TEXT DEFAULT \'\');\x00" as *const u8
+                            as *const libc::c_char,
+                    );
                     dc_sqlite3_execute(
                         sql,
                         b"CREATE INDEX jobs_index1 ON jobs (desired_timestamp);\x00" as *const u8
@@ -232,22 +279,22 @@ pub unsafe fn dc_sqlite3_open(
                                 as *const libc::c_char,
                             dbfile,
                         );
-                        /* cannot create the tables - maybe we cannot write? */
+                        // cannot create the tables - maybe we cannot write?
                         current_block = 13628706266672894061;
                     } else {
                         dc_sqlite3_set_config_int(
                             sql,
                             b"dbversion\x00" as *const u8 as *const libc::c_char,
-                            0i32,
+                            0,
                         );
                         current_block = 14072441030219150333;
                     }
                 } else {
-                    exists_before_update = 1i32;
+                    exists_before_update = 1;
                     dbversion_before_update = dc_sqlite3_get_config_int(
                         sql,
                         b"dbversion\x00" as *const u8 as *const libc::c_char,
-                        0i32,
+                        0,
                     );
                     current_block = 14072441030219150333;
                 }
@@ -259,89 +306,107 @@ pub unsafe fn dc_sqlite3_open(
                         // rely themselves on the low-level structure.
                         // --------------------------------------------------------------------
                         let mut dbversion: libc::c_int = dbversion_before_update;
-                        let mut recalc_fingerprints: libc::c_int = 0i32;
-                        let mut update_file_paths: libc::c_int = 0i32;
-                        if dbversion < 1i32 {
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE TABLE leftgrps ( id INTEGER PRIMARY KEY, grpid TEXT DEFAULT \'\');\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                        let mut recalc_fingerprints: libc::c_int = 0;
+                        let mut update_file_paths: libc::c_int = 0;
+                        if dbversion < 1 {
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE TABLE leftgrps ( id INTEGER PRIMARY KEY, grpid TEXT DEFAULT \'\');\x00"
+                                    as *const u8 as *const libc::c_char
+                            );
                             dc_sqlite3_execute(
                                 sql,
                                 b"CREATE INDEX leftgrps_index1 ON leftgrps (grpid);\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 1i32;
+                            dbversion = 1;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                1i32,
+                                1,
                             );
                         }
-                        if dbversion < 2i32 {
+                        if dbversion < 2 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE contacts ADD COLUMN authname TEXT DEFAULT \'\';\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 2i32;
+                            dbversion = 2;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                2i32,
+                                2,
                             );
                         }
-                        if dbversion < 7i32 {
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE TABLE keypairs ( id INTEGER PRIMARY KEY, addr TEXT DEFAULT \'\' COLLATE NOCASE, is_default INTEGER DEFAULT 0, private_key, public_key, created INTEGER DEFAULT 0);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            dbversion = 7i32;
+                        if dbversion < 7 {
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE TABLE keypairs (\
+                                  id INTEGER PRIMARY KEY, \
+                                  addr TEXT DEFAULT \'\' COLLATE NOCASE, \
+                                  is_default INTEGER DEFAULT 0, \
+                                  private_key, \
+                                  public_key, \
+                                  created INTEGER DEFAULT 0);\x00"
+                                    as *const u8
+                                    as *const libc::c_char,
+                            );
+                            dbversion = 7;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                7i32,
+                                7,
                             );
                         }
-                        if dbversion < 10i32 {
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE TABLE acpeerstates ( id INTEGER PRIMARY KEY, addr TEXT DEFAULT \'\' COLLATE NOCASE, last_seen INTEGER DEFAULT 0, last_seen_autocrypt INTEGER DEFAULT 0, public_key, prefer_encrypted INTEGER DEFAULT 0);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                        if dbversion < 10 {
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE TABLE acpeerstates (\
+                                  id INTEGER PRIMARY KEY, \
+                                  addr TEXT DEFAULT \'\' COLLATE NOCASE, \
+                                  last_seen INTEGER DEFAULT 0, \
+                                  last_seen_autocrypt INTEGER DEFAULT 0, \
+                                  public_key, \
+                                  prefer_encrypted INTEGER DEFAULT 0);\x00"
+                                    as *const u8
+                                    as *const libc::c_char,
+                            );
                             dc_sqlite3_execute(
                                 sql,
                                 b"CREATE INDEX acpeerstates_index1 ON acpeerstates (addr);\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 10i32;
+                            dbversion = 10;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                10i32,
+                                10,
                             );
                         }
-                        if dbversion < 12i32 {
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE TABLE msgs_mdns ( msg_id INTEGER,  contact_id INTEGER);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                        if dbversion < 12 {
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE TABLE msgs_mdns ( msg_id INTEGER,  contact_id INTEGER);\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
                             dc_sqlite3_execute(
                                 sql,
                                 b"CREATE INDEX msgs_mdns_index1 ON msgs_mdns (msg_id);\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 12i32;
+                            dbversion = 12;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                12i32,
+                                12,
                             );
                         }
-                        if dbversion < 17i32 {
+                        if dbversion < 17 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE chats ADD COLUMN archived INTEGER DEFAULT 0;\x00"
@@ -364,40 +429,43 @@ pub unsafe fn dc_sqlite3_open(
                                 b"CREATE INDEX msgs_index5 ON msgs (starred);\x00" as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 17i32;
+                            dbversion = 17;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                17i32,
+                                17,
                             );
                         }
-                        if dbversion < 18i32 {
-                            dc_sqlite3_execute(sql,
-                                               b"ALTER TABLE acpeerstates ADD COLUMN gossip_timestamp INTEGER DEFAULT 0;\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                        if dbversion < 18 {
+                            dc_sqlite3_execute(
+                                sql,
+                                b"ALTER TABLE acpeerstates ADD COLUMN gossip_timestamp INTEGER DEFAULT 0;\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE acpeerstates ADD COLUMN gossip_key;\x00" as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 18i32;
+                            dbversion = 18;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                18i32,
+                                18,
                             );
                         }
-                        if dbversion < 27i32 {
+                        if dbversion < 27 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"DELETE FROM msgs WHERE chat_id=1 OR chat_id=2;\x00" as *const u8
                                     as *const libc::c_char,
                             );
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE INDEX chats_contacts_index2 ON chats_contacts (contact_id);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE INDEX chats_contacts_index2 ON chats_contacts (contact_id);\x00"
+                                    as *const u8 as
+                                    *const libc::c_char
+                            );
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE msgs ADD COLUMN timestamp_sent INTEGER DEFAULT 0;\x00"
@@ -410,134 +478,145 @@ pub unsafe fn dc_sqlite3_open(
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 27i32;
+                            dbversion = 27;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                27i32,
+                                27,
                             );
                         }
-                        if dbversion < 34i32 {
+                        if dbversion < 34 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE msgs ADD COLUMN hidden INTEGER DEFAULT 0;\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dc_sqlite3_execute(sql,
-                                               b"ALTER TABLE msgs_mdns ADD COLUMN timestamp_sent INTEGER DEFAULT 0;\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            dc_sqlite3_execute(sql,
-                                               b"ALTER TABLE acpeerstates ADD COLUMN public_key_fingerprint TEXT DEFAULT \'\';\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            dc_sqlite3_execute(sql,
-                                               b"ALTER TABLE acpeerstates ADD COLUMN gossip_key_fingerprint TEXT DEFAULT \'\';\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE INDEX acpeerstates_index3 ON acpeerstates (public_key_fingerprint);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE INDEX acpeerstates_index4 ON acpeerstates (gossip_key_fingerprint);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            recalc_fingerprints = 1i32;
-                            dbversion = 34i32;
+                            dc_sqlite3_execute(
+                                sql,
+                                b"ALTER TABLE msgs_mdns ADD COLUMN timestamp_sent INTEGER DEFAULT 0;\x00"
+                                    as *const u8 as
+                                    *const libc::c_char
+                            );
+                            dc_sqlite3_execute(
+                                sql,
+                                b"ALTER TABLE acpeerstates ADD COLUMN public_key_fingerprint TEXT DEFAULT \'\';\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
+                            dc_sqlite3_execute(
+                                sql,
+                                b"ALTER TABLE acpeerstates ADD COLUMN gossip_key_fingerprint TEXT DEFAULT \'\';\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE INDEX acpeerstates_index3 ON acpeerstates (public_key_fingerprint);\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE INDEX acpeerstates_index4 ON acpeerstates (gossip_key_fingerprint);\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
+                            recalc_fingerprints = 1;
+                            dbversion = 34;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                34i32,
+                                34,
                             );
                         }
-                        if dbversion < 39i32 {
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE TABLE tokens ( id INTEGER PRIMARY KEY, namespc INTEGER DEFAULT 0, foreign_id INTEGER DEFAULT 0, token TEXT DEFAULT \'\', timestamp INTEGER DEFAULT 0);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                        if dbversion < 39 {
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE TABLE tokens ( id INTEGER PRIMARY KEY, namespc INTEGER DEFAULT 0, foreign_id INTEGER DEFAULT 0, token TEXT DEFAULT \'\', timestamp INTEGER DEFAULT 0);\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE acpeerstates ADD COLUMN verified_key;\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dc_sqlite3_execute(sql,
-                                               b"ALTER TABLE acpeerstates ADD COLUMN verified_key_fingerprint TEXT DEFAULT \'\';\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            dc_sqlite3_execute(sql,
-                                               b"CREATE INDEX acpeerstates_index5 ON acpeerstates (verified_key_fingerprint);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            if dbversion_before_update == 34i32 {
-                                dc_sqlite3_execute(sql,
-                                                   b"UPDATE acpeerstates SET verified_key=gossip_key, verified_key_fingerprint=gossip_key_fingerprint WHERE gossip_key_verified=2;\x00"
-                                                       as *const u8 as
-                                                       *const libc::c_char);
-                                dc_sqlite3_execute(sql,
-                                                   b"UPDATE acpeerstates SET verified_key=public_key, verified_key_fingerprint=public_key_fingerprint WHERE public_key_verified=2;\x00"
-                                                       as *const u8 as
-                                                       *const libc::c_char);
+                            dc_sqlite3_execute(
+                                sql,
+                                b"ALTER TABLE acpeerstates ADD COLUMN verified_key_fingerprint TEXT DEFAULT \'\';\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
+                            dc_sqlite3_execute(
+                                sql,
+                                b"CREATE INDEX acpeerstates_index5 ON acpeerstates (verified_key_fingerprint);\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
+                            if dbversion_before_update == 34 {
+                                dc_sqlite3_execute(
+                                    sql,
+                                    b"UPDATE acpeerstates SET verified_key=gossip_key, verified_key_fingerprint=gossip_key_fingerprint WHERE gossip_key_verified=2;\x00"
+                                        as *const u8 as
+                                        *const libc::c_char);
+                                dc_sqlite3_execute(
+                                    sql,
+                                    b"UPDATE acpeerstates SET verified_key=public_key, verified_key_fingerprint=public_key_fingerprint WHERE public_key_verified=2;\x00"
+                                        as *const u8 as
+                                        *const libc::c_char);
                             }
-                            dbversion = 39i32;
+                            dbversion = 39;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                39i32,
+                                39,
                             );
                         }
-                        if dbversion < 40i32 {
+                        if dbversion < 40 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE jobs ADD COLUMN thread INTEGER DEFAULT 0;\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 40i32;
+                            dbversion = 40;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                40i32,
+                                40,
                             );
                         }
-                        if dbversion < 41i32 {
-                            update_file_paths = 1i32;
-                            dbversion = 41i32;
+                        if dbversion < 41 {
+                            update_file_paths = 1;
+                            dbversion = 41;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                41i32,
+                                41,
                             );
                         }
-                        if dbversion < 42i32 {
+                        if dbversion < 42 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"UPDATE msgs SET txt=\'\' WHERE type!=10\x00" as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 42i32;
+                            dbversion = 42;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                42i32,
+                                42,
                             );
                         }
-                        if dbversion < 44i32 {
+                        if dbversion < 44 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE msgs ADD COLUMN mime_headers TEXT;\x00" as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 44i32;
+                            dbversion = 44;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                44i32,
+                                44,
                             );
                         }
-                        if dbversion < 46i32 {
+                        if dbversion < 46 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE msgs ADD COLUMN mime_in_reply_to TEXT;\x00"
@@ -550,35 +629,35 @@ pub unsafe fn dc_sqlite3_open(
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 46i32;
+                            dbversion = 46;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                46i32,
+                                46,
                             );
                         }
-                        if dbversion < 47i32 {
+                        if dbversion < 47 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE jobs ADD COLUMN tries INTEGER DEFAULT 0;\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 47i32;
+                            dbversion = 47;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                47i32,
+                                47,
                             );
                         }
-                        if dbversion < 48i32 {
+                        if dbversion < 48 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE msgs ADD COLUMN move_state INTEGER DEFAULT 1;\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            if 0 != !(DC_MOVE_STATE_UNDEFINED as libc::c_int == 0i32) as libc::c_int
+                            if 0 != !(DC_MOVE_STATE_UNDEFINED as libc::c_int == 0) as libc::c_int
                                 as libc::c_long
                             {
                                 __assert_rtn(
@@ -587,13 +666,13 @@ pub unsafe fn dc_sqlite3_open(
                                     ))
                                     .as_ptr(),
                                     b"../src/dc_sqlite3.c\x00" as *const u8 as *const libc::c_char,
-                                    559i32,
+                                    559,
                                     b"DC_MOVE_STATE_UNDEFINED == 0\x00" as *const u8
                                         as *const libc::c_char,
                                 );
                             } else {
                             };
-                            if 0 != !(DC_MOVE_STATE_PENDING as libc::c_int == 1i32) as libc::c_int
+                            if 0 != !(DC_MOVE_STATE_PENDING as libc::c_int == 1) as libc::c_int
                                 as libc::c_long
                             {
                                 __assert_rtn(
@@ -602,13 +681,13 @@ pub unsafe fn dc_sqlite3_open(
                                     ))
                                     .as_ptr(),
                                     b"../src/dc_sqlite3.c\x00" as *const u8 as *const libc::c_char,
-                                    560i32,
+                                    560,
                                     b"DC_MOVE_STATE_PENDING == 1\x00" as *const u8
                                         as *const libc::c_char,
                                 );
                             } else {
                             };
-                            if 0 != !(DC_MOVE_STATE_STAY as libc::c_int == 2i32) as libc::c_int
+                            if 0 != !(DC_MOVE_STATE_STAY as libc::c_int == 2) as libc::c_int
                                 as libc::c_long
                             {
                                 __assert_rtn(
@@ -617,13 +696,13 @@ pub unsafe fn dc_sqlite3_open(
                                     ))
                                     .as_ptr(),
                                     b"../src/dc_sqlite3.c\x00" as *const u8 as *const libc::c_char,
-                                    561i32,
+                                    561,
                                     b"DC_MOVE_STATE_STAY == 2\x00" as *const u8
                                         as *const libc::c_char,
                                 );
                             } else {
                             };
-                            if 0 != !(DC_MOVE_STATE_MOVING as libc::c_int == 3i32) as libc::c_int
+                            if 0 != !(DC_MOVE_STATE_MOVING as libc::c_int == 3) as libc::c_int
                                 as libc::c_long
                             {
                                 __assert_rtn(
@@ -632,51 +711,52 @@ pub unsafe fn dc_sqlite3_open(
                                     ))
                                     .as_ptr(),
                                     b"../src/dc_sqlite3.c\x00" as *const u8 as *const libc::c_char,
-                                    562i32,
+                                    562,
                                     b"DC_MOVE_STATE_MOVING == 3\x00" as *const u8
                                         as *const libc::c_char,
                                 );
                             } else {
                             };
-                            dbversion = 48i32;
+                            dbversion = 48;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                48i32,
+                                48,
                             );
                         }
-                        if dbversion < 49i32 {
-                            dc_sqlite3_execute(sql,
-                                               b"ALTER TABLE chats ADD COLUMN gossiped_timestamp INTEGER DEFAULT 0;\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
-                            dbversion = 49i32;
+                        if dbversion < 49 {
+                            dc_sqlite3_execute(
+                                sql,
+                                b"ALTER TABLE chats ADD COLUMN gossiped_timestamp INTEGER DEFAULT 0;\x00"
+                                    as *const u8 as
+                                    *const libc::c_char);
+                            dbversion = 49;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                49i32,
+                                49,
                             );
                         }
-                        if dbversion < 50i32 {
+                        if dbversion < 50 {
                             if 0 != exists_before_update {
                                 dc_sqlite3_set_config_int(
                                     sql,
                                     b"show_emails\x00" as *const u8 as *const libc::c_char,
-                                    2i32,
+                                    2,
                                 );
                             }
-                            dbversion = 50i32;
+                            dbversion = 50;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                50i32,
+                                50,
                             );
                         }
-                        if dbversion < 53i32 {
+                        if dbversion < 53 {
                             dc_sqlite3_execute(sql,
                                                b"CREATE TABLE locations ( id INTEGER PRIMARY KEY AUTOINCREMENT, latitude REAL DEFAULT 0.0, longitude REAL DEFAULT 0.0, accuracy REAL DEFAULT 0.0, timestamp INTEGER DEFAULT 0, chat_id INTEGER DEFAULT 0, from_id INTEGER DEFAULT 0);\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                                               as *const u8 as
+                                               *const libc::c_char);
                             dc_sqlite3_execute(
                                 sql,
                                 b"CREATE INDEX locations_index1 ON locations (from_id);\x00"
@@ -691,30 +771,30 @@ pub unsafe fn dc_sqlite3_open(
                             );
                             dc_sqlite3_execute(sql,
                                                b"ALTER TABLE chats ADD COLUMN locations_send_begin INTEGER DEFAULT 0;\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                                               as *const u8 as
+                                               *const libc::c_char);
                             dc_sqlite3_execute(sql,
                                                b"ALTER TABLE chats ADD COLUMN locations_send_until INTEGER DEFAULT 0;\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                                               as *const u8 as
+                                               *const libc::c_char);
                             dc_sqlite3_execute(sql,
                                                b"ALTER TABLE chats ADD COLUMN locations_last_sent INTEGER DEFAULT 0;\x00"
-                                                   as *const u8 as
-                                                   *const libc::c_char);
+                                               as *const u8 as
+                                               *const libc::c_char);
                             dc_sqlite3_execute(
                                 sql,
                                 b"CREATE INDEX chats_index3 ON chats (locations_send_until);\x00"
                                     as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 53i32;
+                            dbversion = 53;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                53i32,
+                                53,
                             );
                         }
-                        if dbversion < 54i32 {
+                        if dbversion < 54 {
                             dc_sqlite3_execute(
                                 sql,
                                 b"ALTER TABLE msgs ADD COLUMN location_id INTEGER DEFAULT 0;\x00"
@@ -726,11 +806,11 @@ pub unsafe fn dc_sqlite3_open(
                                 b"CREATE INDEX msgs_index6 ON msgs (location_id);\x00" as *const u8
                                     as *const libc::c_char,
                             );
-                            dbversion = 54i32;
+                            dbversion = 54;
                             dc_sqlite3_set_config_int(
                                 sql,
                                 b"dbversion\x00" as *const u8 as *const libc::c_char,
-                                54i32,
+                                54,
                             );
                         }
                         if dbversion < 55 {
@@ -753,16 +833,16 @@ pub unsafe fn dc_sqlite3_open(
                                 b"SELECT addr FROM acpeerstates;\x00" as *const u8
                                     as *const libc::c_char,
                             );
-                            while sqlite3_step(stmt) == 100i32 {
+                            while sqlite3_step(stmt) == 100 {
                                 let mut peerstate: *mut dc_apeerstate_t =
-                                    dc_apeerstate_new((*sql).context);
+                                    dc_apeerstate_new(sql.context);
                                 if 0 != dc_apeerstate_load_by_addr(
                                     peerstate,
                                     sql,
-                                    sqlite3_column_text(stmt, 0i32) as *const libc::c_char,
+                                    sqlite3_column_text(stmt, 0) as *const libc::c_char,
                                 ) && 0 != dc_apeerstate_recalc_fingerprint(peerstate)
                                 {
-                                    dc_apeerstate_save_to_db(peerstate, sql, 0i32);
+                                    dc_apeerstate_save_to_db(peerstate, sql, 0);
                                 }
                                 dc_apeerstate_unref(peerstate);
                             }
@@ -772,7 +852,7 @@ pub unsafe fn dc_sqlite3_open(
                             let mut repl_from: *mut libc::c_char = dc_sqlite3_get_config(
                                 sql,
                                 b"backup_for\x00" as *const u8 as *const libc::c_char,
-                                (*(*sql).context).blobdir,
+                                (*sql.context).blobdir,
                             );
                             dc_ensure_no_slash(repl_from);
                             if 0 != !('f' as i32 == 'f' as i32) as libc::c_int as libc::c_long {
@@ -782,15 +862,15 @@ pub unsafe fn dc_sqlite3_open(
                                     ))
                                     .as_ptr(),
                                     b"../src/dc_sqlite3.c\x00" as *const u8 as *const libc::c_char,
-                                    656i32,
+                                    656,
                                     b"\'f\'==DC_PARAM_FILE\x00" as *const u8 as *const libc::c_char,
                                 );
                             } else {
                             };
                             let mut q3: *mut libc::c_char =
                                 sqlite3_mprintf(b"UPDATE msgs SET param=replace(param, \'f=%q/\', \'f=$BLOBDIR/\');\x00"
-                                                    as *const u8 as
-                                                    *const libc::c_char,
+                                                as *const u8 as
+                                                *const libc::c_char,
                                                 repl_from);
                             dc_sqlite3_execute(sql, q3);
                             sqlite3_free(q3 as *mut libc::c_void);
@@ -801,7 +881,7 @@ pub unsafe fn dc_sqlite3_open(
                                     ))
                                     .as_ptr(),
                                     b"../src/dc_sqlite3.c\x00" as *const u8 as *const libc::c_char,
-                                    661i32,
+                                    661,
                                     b"\'i\'==DC_PARAM_PROFILE_IMAGE\x00" as *const u8
                                         as *const libc::c_char,
                                 );
@@ -809,8 +889,8 @@ pub unsafe fn dc_sqlite3_open(
                             };
                             q3 =
                                 sqlite3_mprintf(b"UPDATE chats SET param=replace(param, \'i=%q/\', \'i=$BLOBDIR/\');\x00"
-                                                    as *const u8 as
-                                                    *const libc::c_char,
+                                                as *const u8 as
+                                                *const libc::c_char,
                                                 repl_from);
                             dc_sqlite3_execute(sql, q3);
                             sqlite3_free(q3 as *mut libc::c_void);
@@ -831,117 +911,122 @@ pub unsafe fn dc_sqlite3_open(
                 13628706266672894061 => {}
                 _ => {
                     dc_log_info(
-                        (*sql).context,
-                        0i32,
+                        sql.context,
+                        0,
                         b"Opened \"%s\".\x00" as *const u8 as *const libc::c_char,
                         dbfile,
                     );
-                    return 1i32;
+                    return 1;
                 }
             }
         }
     }
+
     dc_sqlite3_close(sql);
-    return 0i32;
+    0
 }
-/* handle configurations, private */
+
+// handle configurations, private
 pub unsafe fn dc_sqlite3_set_config(
-    mut sql: *mut dc_sqlite3_t,
-    mut key: *const libc::c_char,
-    mut value: *const libc::c_char,
+    context: &context,
+    sql: &mut dc_sqlite3_t,
+    key: *const libc::c_char,
+    value: *const libc::c_char,
 ) -> libc::c_int {
-    let mut state: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
+    let mut state = 0;
+    let mut stmt = 0 as *mut sqlite3_stmt;
     if key.is_null() {
         dc_log_error(
-            (*sql).context,
-            0i32,
+            context,
+            0,
             b"dc_sqlite3_set_config(): Bad parameter.\x00" as *const u8 as *const libc::c_char,
         );
-        return 0i32;
+        return 0;
     }
     if 0 == dc_sqlite3_is_open(sql) {
         dc_log_error(
-            (*sql).context,
-            0i32,
+            context,
+            0,
             b"dc_sqlite3_set_config(): Database not ready.\x00" as *const u8 as *const libc::c_char,
         );
-        return 0i32;
+        return 0;
     }
     if !value.is_null() {
         stmt = dc_sqlite3_prepare(
             sql,
             b"SELECT value FROM config WHERE keyname=?;\x00" as *const u8 as *const libc::c_char,
         );
-        sqlite3_bind_text(stmt, 1i32, key, -1i32, None);
+        sqlite3_bind_text(stmt, 1, key, -1, None);
         state = sqlite3_step(stmt);
         sqlite3_finalize(stmt);
-        if state == 101i32 {
+        if state == 101 {
             stmt = dc_sqlite3_prepare(
                 sql,
                 b"INSERT INTO config (keyname, value) VALUES (?, ?);\x00" as *const u8
                     as *const libc::c_char,
             );
-            sqlite3_bind_text(stmt, 1i32, key, -1i32, None);
-            sqlite3_bind_text(stmt, 2i32, value, -1i32, None);
+            sqlite3_bind_text(stmt, 1, key, -1, None);
+            sqlite3_bind_text(stmt, 2, value, -1, None);
             state = sqlite3_step(stmt);
             sqlite3_finalize(stmt);
-        } else if state == 100i32 {
+        } else if state == 100 {
             stmt = dc_sqlite3_prepare(
                 sql,
                 b"UPDATE config SET value=? WHERE keyname=?;\x00" as *const u8
                     as *const libc::c_char,
             );
-            sqlite3_bind_text(stmt, 1i32, value, -1i32, None);
-            sqlite3_bind_text(stmt, 2i32, key, -1i32, None);
+            sqlite3_bind_text(stmt, 1, value, -1, None);
+            sqlite3_bind_text(stmt, 2, key, -1, None);
             state = sqlite3_step(stmt);
             sqlite3_finalize(stmt);
         } else {
             dc_log_error(
-                (*sql).context,
-                0i32,
+                context,
+                0,
                 b"dc_sqlite3_set_config(): Cannot read value.\x00" as *const u8
                     as *const libc::c_char,
             );
-            return 0i32;
+            return 0;
         }
     } else {
         stmt = dc_sqlite3_prepare(
             sql,
             b"DELETE FROM config WHERE keyname=?;\x00" as *const u8 as *const libc::c_char,
         );
-        sqlite3_bind_text(stmt, 1i32, key, -1i32, None);
+        sqlite3_bind_text(stmt, 1, key, -1, None);
         state = sqlite3_step(stmt);
         sqlite3_finalize(stmt);
     }
-    if state != 101i32 {
+    if state != 101 {
         dc_log_error(
-            (*sql).context,
-            0i32,
+            context,
+            0,
             b"dc_sqlite3_set_config(): Cannot change value.\x00" as *const u8
                 as *const libc::c_char,
         );
-        return 0i32;
+        return 0;
     }
-    return 1i32;
+
+    1
 }
+
 /* tools, these functions are compatible to the corresponding sqlite3_* functions */
 /* the result mus be freed using sqlite3_finalize() */
 pub unsafe fn dc_sqlite3_prepare(
-    mut sql: *mut dc_sqlite3_t,
-    mut querystr: *const libc::c_char,
+    sql: &mut dc_sqlite3_t,
+    querystr: *const libc::c_char,
 ) -> *mut sqlite3_stmt {
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    if sql.is_null() || querystr.is_null() || (*sql).cobj.is_null() {
+    let mut stmt = 0 as *mut sqlite3_stmt;
+    if querystr.is_null() || sql.cobj.is_null() {
         return 0 as *mut sqlite3_stmt;
     }
     if sqlite3_prepare_v2(
-        (*sql).cobj,
+        sql.cobj,
         querystr,
-        -1i32,
+        -1,
         &mut stmt,
         0 as *mut *const libc::c_char,
-    ) != 0i32
+    ) != 0
     {
         dc_sqlite3_log_error(
             sql,
@@ -950,49 +1035,54 @@ pub unsafe fn dc_sqlite3_prepare(
         );
         return 0 as *mut sqlite3_stmt;
     }
-    return stmt;
+    stmt
 }
+
 pub unsafe extern "C" fn dc_sqlite3_log_error(
-    mut sql: *mut dc_sqlite3_t,
-    mut msg_format: *const libc::c_char,
-    mut va: ...
+    context: &context,
+    sql: &dc_sqlite3_t,
+    msg_format: *const libc::c_char,
+    va: ...
 ) {
-    let mut msg: *mut libc::c_char = 0 as *mut libc::c_char;
-    if sql.is_null() || msg_format.is_null() {
+    let mut msg = 0 as *mut libc::c_char;
+    if msg_format.is_null() {
         return;
     }
     // FIXME: evil transmute
     msg = sqlite3_vmprintf(msg_format, std::mem::transmute(va));
     dc_log_error(
-        (*sql).context,
-        0i32,
+        context,
+        0,
         b"%s SQLite says: %s\x00" as *const u8 as *const libc::c_char,
         if !msg.is_null() {
             msg
         } else {
             b"\x00" as *const u8 as *const libc::c_char
         },
-        if !(*sql).cobj.is_null() {
-            sqlite3_errmsg((*sql).cobj)
+        if !sql.cobj.is_null() {
+            sqlite3_errmsg(sql.cobj)
         } else {
             b"SQLite object not set up.\x00" as *const u8 as *const libc::c_char
         },
     );
     sqlite3_free(msg as *mut libc::c_void);
 }
-pub unsafe fn dc_sqlite3_is_open(mut sql: *const dc_sqlite3_t) -> libc::c_int {
-    if sql.is_null() || (*sql).cobj.is_null() {
-        return 0i32;
+
+pub unsafe fn dc_sqlite3_is_open(sql: &dc_sqlite3_t) -> libc::c_int {
+    if sql.cobj.is_null() {
+        0
+    } else {
+        1
     }
-    return 1i32;
 }
+
 /* the returned string must be free()'d, returns NULL on errors */
 pub unsafe fn dc_sqlite3_get_config(
-    mut sql: *mut dc_sqlite3_t,
-    mut key: *const libc::c_char,
-    mut def: *const libc::c_char,
+    sql: &mut dc_sqlite3_t,
+    key: *const libc::c_char,
+    def: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
+    let mut stmt = 0 as *mut sqlite3_stmt;
     if 0 == dc_sqlite3_is_open(sql) || key.is_null() {
         return dc_strdup_keep_null(def);
     }
@@ -1000,9 +1090,9 @@ pub unsafe fn dc_sqlite3_get_config(
         sql,
         b"SELECT value FROM config WHERE keyname=?;\x00" as *const u8 as *const libc::c_char,
     );
-    sqlite3_bind_text(stmt, 1i32, key, -1i32, None);
-    if sqlite3_step(stmt) == 100i32 {
-        let mut ptr: *const libc::c_uchar = sqlite3_column_text(stmt, 0i32);
+    sqlite3_bind_text(stmt, 1, key, -1, None);
+    if sqlite3_step(stmt) == 100 {
+        let mut ptr: *const libc::c_uchar = sqlite3_column_text(stmt, 0);
         if !ptr.is_null() {
             let mut ret: *mut libc::c_char = dc_strdup(ptr as *const libc::c_char);
             sqlite3_finalize(stmt);
@@ -1010,85 +1100,89 @@ pub unsafe fn dc_sqlite3_get_config(
         }
     }
     sqlite3_finalize(stmt);
-    return dc_strdup_keep_null(def);
+    dc_strdup_keep_null(def)
 }
+
 pub unsafe fn dc_sqlite3_execute(
-    mut sql: *mut dc_sqlite3_t,
-    mut querystr: *const libc::c_char,
+    sql: &mut dc_sqlite3_t,
+    querystr: *const libc::c_char,
 ) -> libc::c_int {
-    let mut success: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut sqlState: libc::c_int = 0i32;
-    stmt = dc_sqlite3_prepare(sql, querystr);
+    let mut success = 0;
+    let mut sqlState = 0;
+    let stmt = dc_sqlite3_prepare(sql, querystr);
     if !stmt.is_null() {
         sqlState = sqlite3_step(stmt);
-        if sqlState != 101i32 && sqlState != 100i32 {
+        if sqlState != 101 && sqlState != 100 {
             dc_sqlite3_log_error(
                 sql,
                 b"Cannot execute \"%s\".\x00" as *const u8 as *const libc::c_char,
                 querystr,
             );
         } else {
-            success = 1i32
+            success = 1
         }
     }
     sqlite3_finalize(stmt);
-    return success;
+    success
 }
+
 pub unsafe fn dc_sqlite3_set_config_int(
-    mut sql: *mut dc_sqlite3_t,
-    mut key: *const libc::c_char,
-    mut value: int32_t,
+    sql: &mut dc_sqlite3_t,
+    key: *const libc::c_char,
+    value: int32_t,
 ) -> libc::c_int {
-    let mut value_str: *mut libc::c_char = dc_mprintf(
+    let mut value_str = dc_mprintf(
         b"%i\x00" as *const u8 as *const libc::c_char,
         value as libc::c_int,
     );
     if value_str.is_null() {
-        return 0i32;
+        return 0;
     }
-    let mut ret: libc::c_int = dc_sqlite3_set_config(sql, key, value_str);
+    let ret = dc_sqlite3_set_config(sql, key, value_str);
     free(value_str as *mut libc::c_void);
-    return ret;
+
+    ret
 }
+
 pub unsafe fn dc_sqlite3_get_config_int(
-    mut sql: *mut dc_sqlite3_t,
-    mut key: *const libc::c_char,
-    mut def: int32_t,
+    sql: &mut dc_sqlite3_t,
+    key: *const libc::c_char,
+    def: int32_t,
 ) -> int32_t {
-    let mut str: *mut libc::c_char = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
+    let mut str = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
     if str.is_null() {
         return def;
     }
-    let mut ret: int32_t = atoi(str) as int32_t;
+    let mut ret = atoi(str) as int32_t;
     free(str as *mut libc::c_void);
-    return ret;
+    ret
 }
+
 pub unsafe fn dc_sqlite3_table_exists(
-    mut sql: *mut dc_sqlite3_t,
-    mut name: *const libc::c_char,
+    sql: &mut dc_sqlite3_t,
+    name: *const libc::c_char,
 ) -> libc::c_int {
-    let mut ret: libc::c_int = 0i32;
-    let mut querystr: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut sqlState: libc::c_int = 0i32;
-    querystr = sqlite3_mprintf(
+    let mut ret = 0;
+    let mut stmt = 0 as *mut sqlite3_stmt;
+    let mut sqlState = 0;
+
+    let querystr = sqlite3_mprintf(
         b"PRAGMA table_info(%s)\x00" as *const u8 as *const libc::c_char,
         name,
     );
     if querystr.is_null() {
         /* this statement cannot be used with binded variables */
         dc_log_error(
-            (*sql).context,
-            0i32,
+            context,
+            0,
             b"dc_sqlite3_table_exists_(): Out of memory.\x00" as *const u8 as *const libc::c_char,
         );
     } else {
         stmt = dc_sqlite3_prepare(sql, querystr);
         if !stmt.is_null() {
             sqlState = sqlite3_step(stmt);
-            if sqlState == 100i32 {
-                ret = 1i32
+            if sqlState == 100 {
+                ret = 1
             }
         }
     }
@@ -1099,104 +1193,109 @@ pub unsafe fn dc_sqlite3_table_exists(
     if !querystr.is_null() {
         sqlite3_free(querystr as *mut libc::c_void);
     }
-    return ret;
+    ret
 }
+
 pub unsafe fn dc_sqlite3_set_config_int64(
-    mut sql: *mut dc_sqlite3_t,
-    mut key: *const libc::c_char,
-    mut value: int64_t,
+    sql: &mutdc_sqlite3_t,
+    key: *const libc::c_char,
+    value: int64_t,
 ) -> libc::c_int {
-    let mut value_str: *mut libc::c_char = dc_mprintf(
+    let mut value_str = dc_mprintf(
         b"%lld\x00" as *const u8 as *const libc::c_char,
         value as libc::c_long,
     );
     if value_str.is_null() {
-        return 0i32;
+        return 0;
     }
-    let mut ret: libc::c_int = dc_sqlite3_set_config(sql, key, value_str);
+    let ret = dc_sqlite3_set_config(sql, key, value_str);
     free(value_str as *mut libc::c_void);
-    return ret;
+    ret
 }
+
 pub unsafe fn dc_sqlite3_get_config_int64(
-    mut sql: *mut dc_sqlite3_t,
-    mut key: *const libc::c_char,
-    mut def: int64_t,
+    sql: &mut dc_sqlite3_t,
+    key: *const libc::c_char,
+    def: int64_t,
 ) -> int64_t {
-    let mut str: *mut libc::c_char = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
+    let mut str = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
     if str.is_null() {
         return def;
     }
-    let mut ret: int64_t = 0i32 as int64_t;
+    let mut ret = 0 as int64_t;
     sscanf(
         str,
         b"%lld\x00" as *const u8 as *const libc::c_char,
         &mut ret as *mut int64_t,
     );
     free(str as *mut libc::c_void);
-    return ret;
+    ret
 }
+
 pub unsafe fn dc_sqlite3_try_execute(
-    mut sql: *mut dc_sqlite3_t,
-    mut querystr: *const libc::c_char,
+    context: &dc_context_t,
+    sql: &mut dc_sqlite3_t,
+    querystr: *const libc::c_char,
 ) -> libc::c_int {
     // same as dc_sqlite3_execute() but does not pass error to ui
-    let mut success: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut sql_state: libc::c_int = 0i32;
-    stmt = dc_sqlite3_prepare(sql, querystr);
+    let mut success = 0;
+    let mut sql_state = 0;
+    let stmt = dc_sqlite3_prepare(sql, querystr);
     if !stmt.is_null() {
         sql_state = sqlite3_step(stmt);
-        if sql_state != 101i32 && sql_state != 100i32 {
+        if sql_state != 101 && sql_state != 100 {
             dc_log_warning(
-                (*sql).context,
-                0i32,
+                context,
+                0,
                 b"Try-execute for \"%s\" failed: %s\x00" as *const u8 as *const libc::c_char,
                 querystr,
-                sqlite3_errmsg((*sql).cobj),
+                sqlite3_errmsg(sql.cobj),
             );
         } else {
-            success = 1i32
+            success = 1
         }
     }
     sqlite3_finalize(stmt);
-    return success;
+    success
 }
+
 pub unsafe fn dc_sqlite3_get_rowid(
-    mut sql: *mut dc_sqlite3_t,
-    mut table: *const libc::c_char,
-    mut field: *const libc::c_char,
-    mut value: *const libc::c_char,
+    sql: &mut dc_sqlite3_t,
+    table: *const libc::c_char,
+    field: *const libc::c_char,
+    value: *const libc::c_char,
 ) -> uint32_t {
     // alternative to sqlite3_last_insert_rowid() which MUST NOT be used due to race conditions, see comment above.
     // the ORDER BY ensures, this function always returns the most recent id,
     // eg. if a Message-ID is splitted into different messages.
-    let mut id: uint32_t = 0i32 as uint32_t;
-    let mut q3: *mut libc::c_char = sqlite3_mprintf(
+    let mut id = 0 as uint32_t;
+    let mut q3 = sqlite3_mprintf(
         b"SELECT id FROM %s WHERE %s=%Q ORDER BY id DESC;\x00" as *const u8 as *const libc::c_char,
         table,
         field,
         value,
     );
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(sql, q3);
-    if 100i32 == sqlite3_step(stmt) {
-        id = sqlite3_column_int(stmt, 0i32) as uint32_t
+    let mut stmt = dc_sqlite3_prepare(sql, q3);
+    if 100 == sqlite3_step(stmt) {
+        id = sqlite3_column_int(stmt, 0) as uint32_t
     }
     sqlite3_finalize(stmt);
     sqlite3_free(q3 as *mut libc::c_void);
-    return id;
+    id
 }
+
 pub unsafe fn dc_sqlite3_get_rowid2(
-    mut sql: *mut dc_sqlite3_t,
-    mut table: *const libc::c_char,
-    mut field: *const libc::c_char,
-    mut value: uint64_t,
-    mut field2: *const libc::c_char,
-    mut value2: uint32_t,
+    sql: &mut dc_sqlite3_t,
+    table: *const libc::c_char,
+    field: *const libc::c_char,
+    value: uint64_t,
+    field2: *const libc::c_char,
+    value2: uint32_t,
 ) -> uint32_t {
     // same as dc_sqlite3_get_rowid() with a key over two columns
-    let mut id: uint32_t = 0i32 as uint32_t;
+    let mut id = 0 as uint32_t;
     // see https://www.sqlite.org/printf.html for sqlite-printf modifiers
-    let mut q3: *mut libc::c_char = sqlite3_mprintf(
+    let mut q3 = sqlite3_mprintf(
         b"SELECT id FROM %s WHERE %s=%lli AND %s=%i ORDER BY id DESC;\x00" as *const u8
             as *const libc::c_char,
         table,
@@ -1205,27 +1304,20 @@ pub unsafe fn dc_sqlite3_get_rowid2(
         field2,
         value2,
     );
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(sql, q3);
-    if 100i32 == sqlite3_step(stmt) {
-        id = sqlite3_column_int(stmt, 0i32) as uint32_t
+    let mut stmt = dc_sqlite3_prepare(sql, q3);
+    if 100 == sqlite3_step(stmt) {
+        id = sqlite3_column_int(stmt, 0) as uint32_t
     }
     sqlite3_finalize(stmt);
     sqlite3_free(q3 as *mut libc::c_void);
-    return id;
+    id
 }
 
-// NOTE: This assumes no transaction usage, port code if this is desired.
-
-pub unsafe fn dc_sqlite3_begin_transaction(_sql: *mut dc_sqlite3_t) {}
-pub unsafe fn dc_sqlite3_commit(_sql: *mut dc_sqlite3_t) {}
-pub unsafe fn dc_sqlite3_rollback(_sql: *mut dc_sqlite3_t) {}
-
-/* housekeeping */
-pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut dir_handle: *mut DIR = 0 as *mut DIR;
-    let mut dir_entry: *mut dirent = 0 as *mut dirent;
-    let mut files_in_use: dc_hash_t = dc_hash_t {
+pub unsafe fn dc_housekeeping(context: &dc_context_t) {
+    let mut stmt = 0 as *mut sqlite3_stmt;
+    let mut dir_handle = 0 as *mut DIR;
+    let mut dir_entry = 0 as *mut dirent;
+    let mut files_in_use = dc_hash_t {
         keyClass: 0,
         copyKey: 0,
         count: 0,
@@ -1233,12 +1325,12 @@ pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
         htsize: 0,
         ht: 0 as *mut _ht,
     };
-    let mut path: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut unreferenced_count: libc::c_int = 0i32;
-    dc_hash_init(&mut files_in_use, 3i32, 1i32);
+    let mut path = 0 as *mut libc::c_char;
+    let mut unreferenced_count = 0;
+    dc_hash_init(&mut files_in_use, 3, 1);
     dc_log_info(
         context,
-        0i32,
+        0,
         b"Start housekeeping...\x00" as *const u8 as *const libc::c_char,
     );
     maybe_add_from_param(
@@ -1270,15 +1362,15 @@ pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
         (*context).sql,
         b"SELECT value FROM config;\x00" as *const u8 as *const libc::c_char,
     );
-    while sqlite3_step(stmt) == 100i32 {
+    while sqlite3_step(stmt) == 100 {
         maybe_add_file(
             &mut files_in_use,
-            sqlite3_column_text(stmt, 0i32) as *const libc::c_char,
+            sqlite3_column_text(stmt, 0) as *const libc::c_char,
         );
     }
     dc_log_info(
         context,
-        0i32,
+        0,
         b"%i files in use.\x00" as *const u8 as *const libc::c_char,
         files_in_use.count as libc::c_int,
     );
@@ -1287,7 +1379,7 @@ pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
     if dir_handle.is_null() {
         dc_log_warning(
             context,
-            0i32,
+            0,
             b"Housekeeping: Cannot open %s.\x00" as *const u8 as *const libc::c_char,
             (*context).blobdir,
         );
@@ -1304,8 +1396,8 @@ pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
             /* name without path or `.` or `..` */
             let mut name: *const libc::c_char = (*dir_entry).d_name.as_mut_ptr();
             let mut name_len: libc::c_int = strlen(name) as libc::c_int;
-            if name_len == 1i32 && *name.offset(0isize) as libc::c_int == '.' as i32
-                || name_len == 2i32
+            if name_len == 1 && *name.offset(0isize) as libc::c_int == '.' as i32
+                || name_len == 2
                     && *name.offset(0isize) as libc::c_int == '.' as i32
                     && *name.offset(1isize) as libc::c_int == '.' as i32
             {
@@ -1346,7 +1438,7 @@ pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
                     {
                         dc_log_info(
                             context,
-                            0i32,
+                            0,
                             b"Housekeeping: Keeping new unreferenced file #%i: %s\x00" as *const u8
                                 as *const libc::c_char,
                             unreferenced_count,
@@ -1359,7 +1451,7 @@ pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
             }
             dc_log_info(
                 context,
-                0i32,
+                0,
                 b"Housekeeping: Deleting unreferenced file #%i: %s\x00" as *const u8
                     as *const libc::c_char,
                 unreferenced_count,
@@ -1376,25 +1468,26 @@ pub unsafe fn dc_housekeeping(mut context: *mut dc_context_t) {
     free(path as *mut libc::c_void);
     dc_log_info(
         context,
-        0i32,
+        0,
         b"Housekeeping done.\x00" as *const u8 as *const libc::c_char,
     );
 }
+
 unsafe fn is_file_in_use(
-    mut files_in_use: *mut dc_hash_t,
-    mut namespc: *const libc::c_char,
-    mut name: *const libc::c_char,
+    files_in_use: *mut dc_hash_t,
+    namespc: *const libc::c_char,
+    name: *const libc::c_char,
 ) -> libc::c_int {
-    let mut name_to_check: *mut libc::c_char = dc_strdup(name);
+    let mut name_to_check = dc_strdup(name);
     if !namespc.is_null() {
         let mut name_len: libc::c_int = strlen(name) as libc::c_int;
         let mut namespc_len: libc::c_int = strlen(namespc) as libc::c_int;
         if name_len <= namespc_len
-            || strcmp(&*name.offset((name_len - namespc_len) as isize), namespc) != 0i32
+            || strcmp(&*name.offset((name_len - namespc_len) as isize), namespc) != 0
         {
-            return 0i32;
+            return 0;
         }
-        *name_to_check.offset((name_len - namespc_len) as isize) = 0i32 as libc::c_char
+        *name_to_check.offset((name_len - namespc_len) as isize) = 0 as libc::c_char
     }
     let mut ret: libc::c_int = (dc_hash_find(
         files_in_use,
@@ -1402,42 +1495,38 @@ unsafe fn is_file_in_use(
         strlen(name_to_check) as libc::c_int,
     ) != 0 as *mut libc::c_void) as libc::c_int;
     free(name_to_check as *mut libc::c_void);
-    return ret;
+    ret
 }
-/* ******************************************************************************
- * Housekeeping
- ******************************************************************************/
-unsafe fn maybe_add_file(mut files_in_use: *mut dc_hash_t, mut file: *const libc::c_char) {
+
+unsafe fn maybe_add_file(files_in_use: *mut dc_hash_t, file: *const libc::c_char) {
     if strncmp(
         file,
         b"$BLOBDIR/\x00" as *const u8 as *const libc::c_char,
         9,
-    ) != 0i32
+    ) != 0
     {
         return;
     }
-    let mut raw_name: *const libc::c_char = &*file.offset(9isize) as *const libc::c_char;
+    let mut raw_name = &*file.offset(9isize) as *const libc::c_char;
     dc_hash_insert(
         files_in_use,
         raw_name as *const libc::c_void,
         strlen(raw_name) as libc::c_int,
-        1i32 as *mut libc::c_void,
+        1 as *mut libc::c_void,
     );
 }
+
 unsafe fn maybe_add_from_param(
-    mut context: *mut dc_context_t,
-    mut files_in_use: *mut dc_hash_t,
-    mut query: *const libc::c_char,
-    mut param_id: libc::c_int,
+    context: &dc_context_t,
+    files_in_use: *mut dc_hash_t,
+    query: *const libc::c_char,
+    param_id: libc::c_int,
 ) {
-    let mut param: *mut dc_param_t = dc_param_new();
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare((*context).sql, query);
-    while sqlite3_step(stmt) == 100i32 {
-        dc_param_set_packed(
-            param,
-            sqlite3_column_text(stmt, 0i32) as *const libc::c_char,
-        );
-        let mut file: *mut libc::c_char = dc_param_get(param, param_id, 0 as *const libc::c_char);
+    let mut param = dc_param_new();
+    let mut stmt = dc_sqlite3_prepare((*context).sql, query);
+    while sqlite3_step(stmt) == 100 {
+        dc_param_set_packed(param, sqlite3_column_text(stmt, 0) as *const libc::c_char);
+        let mut file = dc_param_get(param, param_id, 0 as *const libc::c_char);
         if !file.is_null() {
             maybe_add_file(files_in_use, file);
             free(file as *mut libc::c_void);