diff --git a/examples/repl/cmdline.rs b/examples/repl/cmdline.rs
index bec3bae92..53bd3dc31 100644
--- a/examples/repl/cmdline.rs
+++ b/examples/repl/cmdline.rs
@@ -55,7 +55,7 @@ use num_traits::FromPrimitive;
  *
  * e.g. bitmask 7 triggers actions definded with bits 1, 2 and 4.
  */
-pub unsafe fn dc_reset_tables(mut context: &dc_context_t, mut bits: libc::c_int) -> libc::c_int {
+pub unsafe fn dc_reset_tables(context: &dc_context_t, bits: libc::c_int) -> libc::c_int {
     dc_log_info(
         context,
         0i32,
@@ -144,10 +144,7 @@ pub unsafe fn dc_reset_tables(mut context: &dc_context_t, mut bits: libc::c_int)
     );
     return 1i32;
 }
-unsafe fn dc_poke_eml_file(
-    mut context: &dc_context_t,
-    mut filename: *const libc::c_char,
-) -> libc::c_int {
+unsafe fn dc_poke_eml_file(context: &dc_context_t, filename: *const libc::c_char) -> libc::c_int {
     /* mainly for testing, may be called by dc_import_spec() */
     let mut success: libc::c_int = 0i32;
     let mut data: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -182,7 +179,7 @@ unsafe fn dc_poke_eml_file(
  * @param spec The file or directory to import. NULL for the last command.
  * @return 1=success, 0=error.
  */
-unsafe fn poke_spec(mut context: &dc_context_t, mut spec: *const libc::c_char) -> libc::c_int {
+unsafe fn poke_spec(context: &dc_context_t, spec: *const libc::c_char) -> libc::c_int {
     let mut current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut real_spec: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -262,7 +259,7 @@ unsafe fn poke_spec(mut context: &dc_context_t, mut spec: *const libc::c_char) -
                                     b".eml\x00" as *const u8 as *const libc::c_char,
                                 ) == 0i32
                             {
-                                let mut path_plus_name: *mut libc::c_char = dc_mprintf(
+                                let path_plus_name: *mut libc::c_char = dc_mprintf(
                                     b"%s/%s\x00" as *const u8 as *const libc::c_char,
                                     real_spec,
                                     name,
@@ -314,14 +311,10 @@ unsafe fn poke_spec(mut context: &dc_context_t, mut spec: *const libc::c_char) -
     free(suffix as *mut libc::c_void);
     return success;
 }
-unsafe fn log_msg(
-    mut context: &dc_context_t,
-    mut prefix: *const libc::c_char,
-    mut msg: *mut dc_msg_t,
-) {
-    let mut contact: *mut dc_contact_t = dc_get_contact(context, dc_msg_get_from_id(msg));
-    let mut contact_name: *mut libc::c_char = dc_contact_get_name(contact);
-    let mut contact_id: libc::c_int = dc_contact_get_id(contact) as libc::c_int;
+unsafe fn log_msg(context: &dc_context_t, prefix: *const libc::c_char, msg: *mut dc_msg_t) {
+    let contact: *mut dc_contact_t = dc_get_contact(context, dc_msg_get_from_id(msg));
+    let contact_name: *mut libc::c_char = dc_contact_get_name(contact);
+    let contact_id: libc::c_int = dc_contact_get_id(contact) as libc::c_int;
     let mut statestr: *const libc::c_char = b"\x00" as *const u8 as *const libc::c_char;
     match dc_msg_get_state(msg) {
         20 => statestr = b" o\x00" as *const u8 as *const libc::c_char,
@@ -330,8 +323,8 @@ unsafe fn log_msg(
         24 => statestr = b" !!\x00" as *const u8 as *const libc::c_char,
         _ => {}
     }
-    let mut temp2: *mut libc::c_char = dc_timestamp_to_str(dc_msg_get_timestamp(msg));
-    let mut msgtext: *mut libc::c_char = dc_msg_get_text(msg);
+    let temp2: *mut libc::c_char = dc_timestamp_to_str(dc_msg_get_timestamp(msg));
+    let msgtext: *mut libc::c_char = dc_msg_get_text(msg);
     dc_log_info(
         context,
         0i32,
@@ -378,12 +371,13 @@ unsafe fn log_msg(
     free(contact_name as *mut libc::c_void);
     dc_contact_unref(contact);
 }
-unsafe fn log_msglist(mut context: &dc_context_t, mut msglist: *mut dc_array_t) {
+
+unsafe fn log_msglist(context: &dc_context_t, msglist: *mut dc_array_t) {
     let mut i: libc::c_int = 0;
-    let mut cnt: libc::c_int = dc_array_get_cnt(msglist) as libc::c_int;
+    let cnt: libc::c_int = dc_array_get_cnt(msglist) as libc::c_int;
     let mut lines_out: libc::c_int = 0i32;
     while i < cnt {
-        let mut msg_id: uint32_t = dc_array_get_id(msglist, i as size_t);
+        let msg_id: uint32_t = dc_array_get_id(msglist, i as size_t);
         if msg_id == 9i32 as libc::c_uint {
             dc_log_info(context, 0i32,
                         b"--------------------------------------------------------------------------------\x00"
@@ -396,7 +390,7 @@ unsafe fn log_msglist(mut context: &dc_context_t, mut msglist: *mut dc_array_t)
                                 as *const u8 as *const libc::c_char);
                 lines_out += 1
             }
-            let mut msg: *mut dc_msg_t = dc_get_msg(context, msg_id);
+            let msg: *mut dc_msg_t = dc_get_msg(context, msg_id);
             log_msg(context, b"Msg\x00" as *const u8 as *const libc::c_char, msg);
             dc_msg_unref(msg);
         }
@@ -411,23 +405,23 @@ unsafe fn log_msglist(mut context: &dc_context_t, mut msglist: *mut dc_array_t)
         );
     };
 }
-unsafe fn log_contactlist(mut context: &dc_context_t, mut contacts: *mut dc_array_t) {
+unsafe fn log_contactlist(context: &dc_context_t, contacts: *mut dc_array_t) {
     let mut contact: *mut dc_contact_t;
-    let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+    let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
     if 0 == dc_array_search_id(contacts, 1i32 as uint32_t, 0 as *mut size_t) {
         dc_array_add_id(contacts, 1i32 as uint32_t);
     }
     let mut i = 0;
     while i < dc_array_get_cnt(contacts) {
-        let mut contact_id: uint32_t = dc_array_get_id(contacts, i as size_t);
-        let mut line: *mut libc::c_char;
+        let contact_id: uint32_t = dc_array_get_id(contacts, i as size_t);
+        let line: *mut libc::c_char;
         let mut line2: *mut libc::c_char = 0 as *mut libc::c_char;
         contact = dc_get_contact(context, contact_id);
         if !contact.is_null() {
-            let mut name: *mut libc::c_char = dc_contact_get_name(contact);
-            let mut addr: *mut libc::c_char = dc_contact_get_addr(contact);
-            let mut verified_state: libc::c_int = dc_contact_is_verified(contact);
-            let mut verified_str: *const libc::c_char = if 0 != verified_state {
+            let name: *mut libc::c_char = dc_contact_get_name(contact);
+            let addr: *mut libc::c_char = dc_contact_get_addr(contact);
+            let verified_state: libc::c_int = dc_contact_is_verified(contact);
+            let verified_str: *const libc::c_char = if 0 != verified_state {
                 if verified_state == 2i32 {
                     b" \xe2\x88\x9a\xe2\x88\x9a\x00" as *const u8 as *const libc::c_char
                 } else {
@@ -450,10 +444,10 @@ unsafe fn log_contactlist(mut context: &dc_context_t, mut contacts: *mut dc_arra
                     b"addr unset\x00" as *const u8 as *const libc::c_char
                 },
             );
-            let mut peerstate_ok: libc::c_int =
+            let peerstate_ok: libc::c_int =
                 dc_apeerstate_load_by_addr(peerstate, &context.sql.clone().read().unwrap(), addr);
             if 0 != peerstate_ok && contact_id != 1i32 as libc::c_uint {
-                let mut pe: *mut libc::c_char;
+                let pe: *mut libc::c_char;
                 match (*peerstate).prefer_encrypt {
                     1 => pe = dc_strdup(b"mutual\x00" as *const u8 as *const libc::c_char),
                     0 => pe = dc_strdup(b"no-preference\x00" as *const u8 as *const libc::c_char),
@@ -498,7 +492,7 @@ static mut s_is_auth: libc::c_int = 0i32;
 pub unsafe fn dc_cmdline_skip_auth() {
     s_is_auth = 1i32;
 }
-unsafe fn chat_prefix(mut chat: *const dc_chat_t) -> *const libc::c_char {
+unsafe fn chat_prefix(chat: *const dc_chat_t) -> *const libc::c_char {
     if (*chat).type_0 == 120i32 {
         return b"Group\x00" as *const u8 as *const libc::c_char;
     } else if (*chat).type_0 == 130i32 {
@@ -539,8 +533,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if 0 == s_is_auth {
         if strcmp(cmd, b"auth\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            let mut is_pw =
-                dc_get_config(context, b"mail_pw\x00" as *const u8 as *const libc::c_char);
+            let is_pw = dc_get_config(context, b"mail_pw\x00" as *const u8 as *const libc::c_char);
             if arg1 == CStr::from_ptr(is_pw).to_str().unwrap() {
                 s_is_auth = 1;
                 ret = 2i32 as *mut libc::c_char
@@ -576,7 +569,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         b"initiate-key-transfer\x00" as *const u8 as *const libc::c_char,
     ) == 0i32
     {
-        let mut setup_code: *mut libc::c_char = dc_initiate_key_transfer(context);
+        let setup_code: *mut libc::c_char = dc_initiate_key_transfer(context);
         ret = if !setup_code.is_null() {
             dc_mprintf(
                 b"Setup code for the transferred setup message: %s\x00" as *const u8
@@ -593,10 +586,10 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     ) == 0i32
     {
         if !arg1.is_empty() {
-            let mut msg_id: u32 = arg1.parse().unwrap();
-            let mut msg: *mut dc_msg_t = dc_get_msg(context, msg_id);
+            let msg_id: u32 = arg1.parse().unwrap();
+            let msg: *mut dc_msg_t = dc_get_msg(context, msg_id);
             if 0 != dc_msg_is_setupmessage(msg) {
-                let mut setupcodebegin: *mut libc::c_char = dc_msg_get_setupcodebegin(msg);
+                let setupcodebegin: *mut libc::c_char = dc_msg_get_setupcodebegin(msg);
                 ret = dc_mprintf(
                     b"The setup code for setup message Msg#%i starts with: %s\x00" as *const u8
                         as *const libc::c_char,
@@ -681,12 +674,12 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         );
         ret = 2i32 as *mut libc::c_char
     } else if strcmp(cmd, b"export-setup\x00" as *const u8 as *const libc::c_char) == 0i32 {
-        let mut setup_code_0: *mut libc::c_char = dc_create_setup_code(context);
-        let mut file_name: *mut libc::c_char = dc_mprintf(
+        let setup_code_0: *mut libc::c_char = dc_create_setup_code(context);
+        let file_name: *mut libc::c_char = dc_mprintf(
             b"%s/autocrypt-setup-message.html\x00" as *const u8 as *const libc::c_char,
             context.get_blobdir(),
         );
-        let mut file_content: *mut libc::c_char;
+        let file_content: *mut libc::c_char;
         file_content = dc_render_setup_file(context, setup_code_0);
         if !file_content.is_null()
             && 0 != dc_write_file(
@@ -716,7 +709,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"reset\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut bits: libc::c_int = arg1.parse().unwrap();
+            let bits: libc::c_int = arg1.parse().unwrap();
             if bits > 15i32 {
                 ret = dc_strdup(
                     b"ERROR: <bits> must be lower than 16.\x00" as *const u8 as *const libc::c_char,
@@ -749,7 +742,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"get\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut val: *mut libc::c_char = dc_get_config(context, arg1_c.as_ptr());
+            let val: *mut libc::c_char = dc_get_config(context, arg1_c.as_ptr());
             ret = dc_mprintf(
                 b"%s=%s\x00" as *const u8 as *const libc::c_char,
                 arg1_c.as_ptr(),
@@ -775,18 +768,18 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         || strcmp(cmd, b"listarchived\x00" as *const u8 as *const libc::c_char) == 0i32
         || strcmp(cmd, b"chats\x00" as *const u8 as *const libc::c_char) == 0i32
     {
-        let mut listflags: libc::c_int =
+        let listflags: libc::c_int =
             if strcmp(cmd, b"listarchived\x00" as *const u8 as *const libc::c_char) == 0i32 {
                 0x1i32
             } else {
                 0i32
             };
 
-        let mut chatlist: *mut dc_chatlist_t =
+        let chatlist: *mut dc_chatlist_t =
             dc_get_chatlist(context, listflags, arg1_c.as_ptr(), 0i32 as uint32_t);
         if !chatlist.is_null() {
             let mut i: libc::c_int;
-            let mut cnt: libc::c_int = dc_chatlist_get_cnt(chatlist) as libc::c_int;
+            let cnt: libc::c_int = dc_chatlist_get_cnt(chatlist) as libc::c_int;
             if cnt > 0i32 {
                 dc_log_info(context, 0i32,
                                 b"================================================================================\x00"
@@ -794,10 +787,10 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
                 i = cnt - 1i32;
 
                 while i >= 0i32 {
-                    let mut chat: *mut dc_chat_t =
+                    let chat: *mut dc_chat_t =
                         dc_get_chat(context, dc_chatlist_get_chat_id(chatlist, i as size_t));
-                    let mut temp_subtitle: *mut libc::c_char = dc_chat_get_subtitle(chat);
-                    let mut temp_name: *mut libc::c_char = dc_chat_get_name(chat);
+                    let temp_subtitle: *mut libc::c_char = dc_chat_get_subtitle(chat);
+                    let temp_name: *mut libc::c_char = dc_chat_get_name(chat);
                     dc_log_info(
                         context,
                         0i32,
@@ -810,8 +803,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
                     );
                     free(temp_subtitle as *mut libc::c_void);
                     free(temp_name as *mut libc::c_void);
-                    let mut lot: *mut dc_lot_t =
-                        dc_chatlist_get_summary(chatlist, i as size_t, chat);
+                    let lot: *mut dc_lot_t = dc_chatlist_get_summary(chatlist, i as size_t, chat);
                     let mut statestr: *const libc::c_char =
                         b"\x00" as *const u8 as *const libc::c_char;
                     if 0 != dc_chat_get_archived(chat) {
@@ -830,10 +822,9 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
                             _ => {}
                         }
                     }
-                    let mut timestr: *mut libc::c_char =
-                        dc_timestamp_to_str(dc_lot_get_timestamp(lot));
-                    let mut text1: *mut libc::c_char = dc_lot_get_text1(lot);
-                    let mut text2: *mut libc::c_char = dc_lot_get_text2(lot);
+                    let timestr: *mut libc::c_char = dc_timestamp_to_str(dc_lot_get_timestamp(lot));
+                    let text1: *mut libc::c_char = dc_lot_get_text1(lot);
+                    let text2: *mut libc::c_char = dc_lot_get_text2(lot);
                     dc_log_info(
                         context,
                         0i32,
@@ -898,14 +889,14 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
             *context.cmdline_sel_chat_id.write().unwrap() = chat_id;
         }
         if !sel_chat.is_null() {
-            let mut msglist: *mut dc_array_t = dc_get_chat_msgs(
+            let msglist: *mut dc_array_t = dc_get_chat_msgs(
                 context,
                 dc_chat_get_id(sel_chat),
                 0x1i32 as uint32_t,
                 0i32 as uint32_t,
             );
-            let mut temp2: *mut libc::c_char = dc_chat_get_subtitle(sel_chat);
-            let mut temp_name_0: *mut libc::c_char = dc_chat_get_name(sel_chat);
+            let temp2: *mut libc::c_char = dc_chat_get_subtitle(sel_chat);
+            let temp_name_0: *mut libc::c_char = dc_chat_get_name(sel_chat);
             dc_log_info(
                 context,
                 0i32,
@@ -926,7 +917,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
                 log_msglist(context, msglist);
                 dc_array_unref(msglist);
             }
-            let mut draft: *mut dc_msg_t = dc_get_draft(context, dc_chat_get_id(sel_chat));
+            let draft: *mut dc_msg_t = dc_get_draft(context, dc_chat_get_id(sel_chat));
             if !draft.is_null() {
                 log_msg(
                     context,
@@ -945,8 +936,8 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"createchat\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut contact_id: libc::c_int = arg1.parse().unwrap();
-            let mut chat_id: libc::c_int =
+            let contact_id: libc::c_int = arg1.parse().unwrap();
+            let chat_id: libc::c_int =
                 dc_create_chat_by_contact_id(context, contact_id as uint32_t) as libc::c_int;
             ret = if chat_id != 0i32 {
                 dc_mprintf(
@@ -967,11 +958,11 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     ) == 0i32
     {
         if !arg1.is_empty() {
-            let mut msg_id_0: libc::c_int = arg1.parse().unwrap();
-            let mut chat_id_0: libc::c_int =
+            let msg_id_0: libc::c_int = arg1.parse().unwrap();
+            let chat_id_0: libc::c_int =
                 dc_create_chat_by_msg_id(context, msg_id_0 as uint32_t) as libc::c_int;
             if chat_id_0 != 0i32 {
-                let mut chat_0: *mut dc_chat_t = dc_get_chat(context, chat_id_0 as uint32_t);
+                let chat_0: *mut dc_chat_t = dc_get_chat(context, chat_id_0 as uint32_t);
                 ret = dc_mprintf(
                     b"%s#%lu created successfully.\x00" as *const u8 as *const libc::c_char,
                     chat_prefix(chat_0),
@@ -988,7 +979,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"creategroup\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut chat_id_1: libc::c_int =
+            let chat_id_1: libc::c_int =
                 dc_create_group_chat(context, 0i32, arg1_c.as_ptr()) as libc::c_int;
             ret = if chat_id_1 != 0i32 {
                 dc_mprintf(
@@ -1009,7 +1000,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     ) == 0i32
     {
         if !arg1.is_empty() {
-            let mut chat_id_2: libc::c_int =
+            let chat_id_2: libc::c_int =
                 dc_create_group_chat(context, 1i32, arg1_c.as_ptr()) as libc::c_int;
             ret = if chat_id_2 != 0i32 {
                 dc_mprintf(
@@ -1028,7 +1019,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     } else if strcmp(cmd, b"addmember\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !sel_chat.is_null() {
             if !arg1.is_empty() {
-                let mut contact_id_0: libc::c_int = arg1.parse().unwrap();
+                let contact_id_0: libc::c_int = arg1.parse().unwrap();
                 if 0 != dc_add_contact_to_chat(
                     context,
                     dc_chat_get_id(sel_chat),
@@ -1054,7 +1045,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     } else if strcmp(cmd, b"removemember\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !sel_chat.is_null() {
             if !arg1.is_empty() {
-                let mut contact_id_1: libc::c_int = arg1.parse().unwrap();
+                let contact_id_1: libc::c_int = arg1.parse().unwrap();
                 if 0 != dc_remove_contact_from_chat(
                     context,
                     dc_chat_get_id(sel_chat),
@@ -1114,8 +1105,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"chatinfo\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !sel_chat.is_null() {
-            let mut contacts: *mut dc_array_t =
-                dc_get_chat_contacts(context, dc_chat_get_id(sel_chat));
+            let contacts: *mut dc_array_t = dc_get_chat_contacts(context, dc_chat_get_id(sel_chat));
             if !contacts.is_null() {
                 dc_log_info(
                     context,
@@ -1136,12 +1126,12 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
             ret = dc_strdup(b"No chat selected.\x00" as *const u8 as *const libc::c_char)
         }
     } else if strcmp(cmd, b"getlocations\x00" as *const u8 as *const libc::c_char) == 0i32 {
-        let mut contact_id_2: libc::c_int = if !arg1.is_empty() {
+        let contact_id_2: libc::c_int = if !arg1.is_empty() {
             arg1.parse().unwrap()
         } else {
             0i32
         };
-        let mut loc: *mut dc_array_t = dc_get_locations(
+        let loc: *mut dc_array_t = dc_get_locations(
             context,
             dc_chat_get_id(sel_chat),
             contact_id_2 as uint32_t,
@@ -1150,9 +1140,9 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         );
         let mut j = 0;
         while j < dc_array_get_cnt(loc) {
-            let mut timestr_0: *mut libc::c_char =
+            let timestr_0: *mut libc::c_char =
                 dc_timestamp_to_str(dc_array_get_timestamp(loc, j as size_t));
-            let mut marker: *mut libc::c_char = dc_array_get_marker(loc, j as size_t);
+            let marker: *mut libc::c_char = dc_array_get_marker(loc, j as size_t);
             dc_log_info(
                 context,
                 0i32,
@@ -1192,7 +1182,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     {
         if !sel_chat.is_null() {
             if !arg1.is_empty() {
-                let mut seconds: libc::c_int = arg1.parse().unwrap();
+                let seconds: libc::c_int = arg1.parse().unwrap();
                 dc_send_locations_to_chat(context, dc_chat_get_id(sel_chat), seconds);
                 ret =
                         dc_mprintf(b"Locations will be sent to Chat#%i for %i seconds. Use \'setlocation <lat> <lng>\' to play around.\x00"
@@ -1206,9 +1196,9 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"setlocation\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() && !arg2.is_empty() {
-            let mut latitude: libc::c_double = arg1.parse().unwrap();
-            let mut longitude: libc::c_double = arg2.parse().unwrap();
-            let mut continue_streaming: libc::c_int =
+            let latitude: libc::c_double = arg1.parse().unwrap();
+            let longitude: libc::c_double = arg2.parse().unwrap();
+            let continue_streaming: libc::c_int =
                 dc_set_location(context, latitude, longitude, 0.0f64);
             ret = dc_strdup(if 0 != continue_streaming {
                 b"Success, streaming should be continued.\x00" as *const u8 as *const libc::c_char
@@ -1259,7 +1249,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     {
         if !sel_chat.is_null() {
             if !arg1.is_empty() && !arg2.is_empty() {
-                let mut msg_0: *mut dc_msg_t = dc_msg_new(
+                let msg_0: *mut dc_msg_t = dc_msg_new(
                     context,
                     if strcmp(cmd, b"sendimage\x00" as *const u8 as *const libc::c_char) == 0i32 {
                         20i32
@@ -1280,7 +1270,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"listmsgs\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut msglist_0: *mut dc_array_t = dc_search_msgs(
+            let msglist_0: *mut dc_array_t = dc_search_msgs(
                 context,
                 if !sel_chat.is_null() {
                     dc_chat_get_id(sel_chat)
@@ -1305,7 +1295,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     } else if strcmp(cmd, b"draft\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !sel_chat.is_null() {
             if !arg1.is_empty() {
-                let mut draft_0: *mut dc_msg_t = dc_msg_new(context, 10i32);
+                let draft_0: *mut dc_msg_t = dc_msg_new(context, 10i32);
                 dc_msg_set_text(draft_0, arg1_c.as_ptr());
                 dc_set_draft(context, dc_chat_get_id(sel_chat), draft_0);
                 dc_msg_unref(draft_0);
@@ -1319,17 +1309,17 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"listmedia\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !sel_chat.is_null() {
-            let mut images: *mut dc_array_t =
+            let images: *mut dc_array_t =
                 dc_get_chat_media(context, dc_chat_get_id(sel_chat), 20i32, 21i32, 50i32);
             let mut i_0: libc::c_int;
-            let mut icnt: libc::c_int = dc_array_get_cnt(images) as libc::c_int;
+            let icnt: libc::c_int = dc_array_get_cnt(images) as libc::c_int;
             ret = dc_mprintf(
                 b"%i images or videos: \x00" as *const u8 as *const libc::c_char,
                 icnt,
             );
             i_0 = 0i32;
             while i_0 < icnt {
-                let mut temp: *mut libc::c_char = dc_mprintf(
+                let temp: *mut libc::c_char = dc_mprintf(
                     b"%s%sMsg#%i\x00" as *const u8 as *const libc::c_char,
                     if 0 != i_0 {
                         b", \x00" as *const u8 as *const libc::c_char
@@ -1351,7 +1341,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         || strcmp(cmd, b"unarchive\x00" as *const u8 as *const libc::c_char) == 0i32
     {
         if !arg1.is_empty() {
-            let mut chat_id_3: libc::c_int = arg1.parse().unwrap();
+            let chat_id_3: libc::c_int = arg1.parse().unwrap();
             dc_archive_chat(
                 context,
                 chat_id_3 as uint32_t,
@@ -1369,7 +1359,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"delchat\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut chat_id_4: libc::c_int = arg1.parse().unwrap();
+            let chat_id_4: libc::c_int = arg1.parse().unwrap();
             dc_delete_chat(context, chat_id_4 as uint32_t);
             ret = 2i32 as *mut libc::c_char
         } else {
@@ -1379,7 +1369,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"msginfo\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut id: libc::c_int = arg1.parse().unwrap();
+            let id: libc::c_int = arg1.parse().unwrap();
             ret = dc_get_msg_info(context, id as uint32_t)
         } else {
             ret = dc_strdup(
@@ -1387,7 +1377,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
             )
         }
     } else if strcmp(cmd, b"listfresh\x00" as *const u8 as *const libc::c_char) == 0i32 {
-        let mut msglist_1: *mut dc_array_t = dc_get_fresh_msgs(context);
+        let msglist_1: *mut dc_array_t = dc_get_fresh_msgs(context);
         if !msglist_1.is_null() {
             log_msglist(context, msglist_1);
             ret = dc_mprintf(
@@ -1399,7 +1389,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
     } else if strcmp(cmd, b"forward\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() && !arg2.is_empty() {
             let mut msg_ids: [uint32_t; 1] = [0; 1];
-            let mut chat_id_5: uint32_t = arg2.parse().unwrap();
+            let chat_id_5: uint32_t = arg2.parse().unwrap();
             msg_ids[0usize] = arg1.parse().unwrap();
             dc_forward_msgs(context, msg_ids.as_mut_ptr(), 1i32, chat_id_5);
             ret = 2i32 as *mut libc::c_char
@@ -1457,7 +1447,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         || strcmp(cmd, b"contacts\x00" as *const u8 as *const libc::c_char) == 0i32
         || strcmp(cmd, b"listverified\x00" as *const u8 as *const libc::c_char) == 0i32
     {
-        let mut contacts_0: *mut dc_array_t = dc_get_contacts(
+        let contacts_0: *mut dc_array_t = dc_get_contacts(
             context,
             (if strcmp(cmd, b"listverified\x00" as *const u8 as *const libc::c_char) == 0i32 {
                 0x1i32 | 0x2i32
@@ -1478,7 +1468,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"addcontact\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() && !arg2.is_empty() {
-            let mut book: *mut libc::c_char = dc_mprintf(
+            let book: *mut libc::c_char = dc_mprintf(
                 b"%s\n%s\x00" as *const u8 as *const libc::c_char,
                 arg1_c.as_ptr(),
                 arg2_c.as_ptr(),
@@ -1500,7 +1490,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"contactinfo\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut contact_id_3: libc::c_int = arg1.parse().unwrap();
+            let contact_id_3: libc::c_int = arg1.parse().unwrap();
             let mut strbuilder: dc_strbuilder_t = dc_strbuilder_t {
                 buf: 0 as *mut libc::c_char,
                 allocated: 0,
@@ -1509,8 +1499,8 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
             };
 
             dc_strbuilder_init(&mut strbuilder, 0i32);
-            let mut contact: *mut dc_contact_t = dc_get_contact(context, contact_id_3 as uint32_t);
-            let mut nameNaddr: *mut libc::c_char = dc_contact_get_name_n_addr(contact);
+            let contact: *mut dc_contact_t = dc_get_contact(context, contact_id_3 as uint32_t);
+            let nameNaddr: *mut libc::c_char = dc_contact_get_name_n_addr(contact);
             dc_strbuilder_catf(
                 &mut strbuilder as *mut dc_strbuilder_t,
                 b"Contact info for: %s:\n\n\x00" as *const u8 as *const libc::c_char,
@@ -1518,17 +1508,17 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
             );
             free(nameNaddr as *mut libc::c_void);
             dc_contact_unref(contact);
-            let mut encrinfo: *mut libc::c_char =
+            let encrinfo: *mut libc::c_char =
                 dc_get_contact_encrinfo(context, contact_id_3 as uint32_t);
             dc_strbuilder_cat(&mut strbuilder, encrinfo);
             free(encrinfo as *mut libc::c_void);
-            let mut chatlist_0: *mut dc_chatlist_t = dc_get_chatlist(
+            let chatlist_0: *mut dc_chatlist_t = dc_get_chatlist(
                 context,
                 0i32,
                 0 as *const libc::c_char,
                 contact_id_3 as uint32_t,
             );
-            let mut chatlist_cnt: libc::c_int = dc_chatlist_get_cnt(chatlist_0) as libc::c_int;
+            let chatlist_cnt: libc::c_int = dc_chatlist_get_cnt(chatlist_0) as libc::c_int;
             if chatlist_cnt > 0i32 {
                 dc_strbuilder_catf(
                     &mut strbuilder as *mut dc_strbuilder_t,
@@ -1545,7 +1535,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
                             b", \x00" as *const u8 as *const libc::c_char,
                         );
                     }
-                    let mut chat_1: *mut dc_chat_t =
+                    let chat_1: *mut dc_chat_t =
                         dc_get_chat(context, dc_chatlist_get_chat_id(chatlist_0, i_1 as size_t));
                     dc_strbuilder_catf(
                         &mut strbuilder as *mut dc_strbuilder_t,
@@ -1591,7 +1581,7 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"checkqr\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut res: *mut dc_lot_t = dc_check_qr(context, arg1_c.as_ptr());
+            let res: *mut dc_lot_t = dc_check_qr(context, arg1_c.as_ptr());
             ret = dc_mprintf(
                 b"state=%i, id=%i, text1=%s, text2=%s\x00" as *const u8 as *const libc::c_char,
                 (*res).state as libc::c_int,
@@ -1615,9 +1605,8 @@ pub unsafe fn dc_cmdline(context: &dc_context_t, cmdline: &str) -> *mut libc::c_
         }
     } else if strcmp(cmd, b"event\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !arg1.is_empty() {
-            let mut event = Event::from_u32(arg1.parse().unwrap()).unwrap();
-            let mut r: uintptr_t =
-                (context.cb)(context, event, 0i32 as uintptr_t, 0i32 as uintptr_t);
+            let event = Event::from_u32(arg1.parse().unwrap()).unwrap();
+            let r: uintptr_t = (context.cb)(context, event, 0i32 as uintptr_t, 0i32 as uintptr_t);
             ret = dc_mprintf(
                 b"Sending event %i, received value %i.\x00" as *const u8 as *const libc::c_char,
                 event as libc::c_int,
diff --git a/examples/repl/main.rs b/examples/repl/main.rs
index b53b2d2cb..b5803a0ca 100644
--- a/examples/repl/main.rs
+++ b/examples/repl/main.rs
@@ -11,7 +11,6 @@
     non_camel_case_types,
     non_snake_case,
     non_upper_case_globals,
-    unused_mut,
     unused_attributes,
     non_upper_case_globals,
     non_camel_case_types,
@@ -136,8 +135,9 @@ unsafe extern "C" fn receive_event(
             );
         }
         2100 | 2110 => {
-            let mut url: *mut libc::c_char = dc_strdup(data1 as *mut libc::c_char);
+            let url: *mut libc::c_char = dc_strdup(data1 as *mut libc::c_char);
             let mut param: *mut libc::c_char = strchr(url, '?' as i32);
+
             if !param.is_null() {
                 *param = 0i32 as libc::c_char;
                 param = param.offset(1isize)
@@ -145,12 +145,12 @@ unsafe extern "C" fn receive_event(
                 param = b"\x00" as *const u8 as *const libc::c_char as *mut libc::c_char
             }
             let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
-            let mut tempFile: *mut libc::c_char = dc_get_fine_pathNfilename(
+            let tempFile: *mut libc::c_char = dc_get_fine_pathNfilename(
                 context,
                 context.get_blobdir(),
                 b"curl.result\x00" as *const u8 as *const libc::c_char,
             );
-            let mut cmd: *mut libc::c_char = if event == Event::HTTP_GET {
+            let cmd: *mut libc::c_char = if event == Event::HTTP_GET {
                 dc_mprintf(
                     b"curl --silent --location --fail --insecure %s%s%s > %s\x00" as *const u8
                         as *const libc::c_char,
@@ -171,7 +171,7 @@ unsafe extern "C" fn receive_event(
                     tempFile,
                 )
             };
-            let mut error: libc::c_int = system(cmd);
+            let error: libc::c_int = system(cmd);
             if error == 0i32 {
                 let mut bytes: size_t = 0i32 as size_t;
                 dc_read_file(
@@ -357,7 +357,7 @@ fn read_cmd() -> String {
     input.trim_end().to_string()
 }
 
-unsafe fn main_0(mut argc: libc::c_int, mut argv: *mut *mut libc::c_char) -> libc::c_int {
+unsafe fn main_0(argc: libc::c_int, argv: *mut *mut libc::c_char) -> libc::c_int {
     let mut cmd: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut context = dc_context_new(
         receive_event,
@@ -421,14 +421,14 @@ unsafe fn main_0(mut argc: libc::c_int, mut argv: *mut *mut libc::c_char) -> lib
             handles = { Some(start_threads(ctx.clone())) };
             dc_configure(&ctx.read().unwrap());
         } else if strcmp(cmd, b"oauth2\x00" as *const u8 as *const libc::c_char) == 0i32 {
-            let mut addr: *mut libc::c_char = dc_get_config(
+            let addr: *mut libc::c_char = dc_get_config(
                 &ctx.read().unwrap(),
                 b"addr\x00" as *const u8 as *const libc::c_char,
             );
             if addr.is_null() || *addr.offset(0isize) as libc::c_int == 0i32 {
                 printf(b"oauth2: set addr first.\n\x00" as *const u8 as *const libc::c_char);
             } else {
-                let mut oauth2_url: *mut libc::c_char = dc_get_oauth2_url(
+                let oauth2_url: *mut libc::c_char = dc_get_oauth2_url(
                     &ctx.read().unwrap(),
                     addr,
                     b"chat.delta:/com.b44t.messenger\x00" as *const u8 as *const libc::c_char,
@@ -453,7 +453,7 @@ unsafe fn main_0(mut argc: libc::c_int, mut argv: *mut *mut libc::c_char) -> lib
             || strcmp(cmd, b"getbadqr\x00" as *const u8 as *const libc::c_char) == 0i32
         {
             handles = Some(start_threads(ctx.clone()));
-            let mut qrstr: *mut libc::c_char = dc_get_securejoin_qr(
+            let qrstr: *mut libc::c_char = dc_get_securejoin_qr(
                 &ctx.read().unwrap(),
                 (if !arg1.is_null() { atoi(arg1) } else { 0i32 }) as uint32_t,
             );
@@ -468,7 +468,7 @@ unsafe fn main_0(mut argc: libc::c_int, mut argv: *mut *mut libc::c_char) -> lib
                     }
                 }
                 printf(b"%s\n\x00" as *const u8 as *const libc::c_char, qrstr);
-                let mut syscmd: *mut libc::c_char = dc_mprintf(
+                let syscmd: *mut libc::c_char = dc_mprintf(
                     b"qrencode -t ansiutf8 \"%s\" -o -\x00" as *const u8 as *const libc::c_char,
                     qrstr,
                 );
@@ -486,8 +486,7 @@ unsafe fn main_0(mut argc: libc::c_int, mut argv: *mut *mut libc::c_char) -> lib
                 break;
             }
             if !(*cmd.offset(0isize) as libc::c_int == 0i32) {
-                let mut execute_result: *mut libc::c_char =
-                    dc_cmdline(&ctx.read().unwrap(), &cmdline);
+                let execute_result: *mut libc::c_char = dc_cmdline(&ctx.read().unwrap(), &cmdline);
                 if !execute_result.is_null() {
                     printf(
                         b"%s\n\x00" as *const u8 as *const libc::c_char,
diff --git a/src/dc_aheader.rs b/src/dc_aheader.rs
index b23d75532..6f76073f2 100644
--- a/src/dc_aheader.rs
+++ b/src/dc_aheader.rs
@@ -31,8 +31,8 @@ pub unsafe fn dc_aheader_new() -> *mut dc_aheader_t {
 }
 
 pub unsafe fn dc_aheader_new_from_imffields(
-    mut wanted_from: *const libc::c_char,
-    mut header: *const mailimf_fields,
+    wanted_from: *const libc::c_char,
+    header: *const mailimf_fields,
 ) -> *mut dc_aheader_t {
     let mut cur;
     let mut fine_header = 0 as *mut dc_aheader_t;
@@ -43,14 +43,14 @@ pub unsafe fn dc_aheader_new_from_imffields(
 
     cur = (*(*header).fld_list).first;
     while !cur.is_null() {
-        let mut field = (if !cur.is_null() {
+        let field = (if !cur.is_null() {
             (*cur).data
         } else {
             0 as *mut libc::c_void
         }) as *mut mailimf_field;
 
         if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let mut optional_field = (*field).fld_data.fld_optional_field;
+            let optional_field = (*field).fld_data.fld_optional_field;
             if !optional_field.is_null()
                 && !(*optional_field).fld_name.is_null()
                 && strcasecmp(
@@ -85,7 +85,7 @@ pub unsafe fn dc_aheader_new_from_imffields(
     fine_header
 }
 
-pub unsafe fn dc_aheader_unref(mut aheader: *mut dc_aheader_t) {
+pub unsafe fn dc_aheader_unref(aheader: *mut dc_aheader_t) {
     if aheader.is_null() {
         return;
     }
@@ -96,9 +96,9 @@ pub unsafe fn dc_aheader_unref(mut aheader: *mut dc_aheader_t) {
 
 pub unsafe fn dc_aheader_set_from_string(
     mut aheader: *mut dc_aheader_t,
-    mut header_str__: *const libc::c_char,
+    header_str__: *const libc::c_char,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     /* according to RFC 5322 (Internet Message Format), the given string may contain `\r\n` before any whitespace.
     we can ignore this issue as
     (a) no key or value is expected to contain spaces,
@@ -190,8 +190,8 @@ pub unsafe fn dc_aheader_empty(mut aheader: *mut dc_aheader_t) {
 
 unsafe fn add_attribute(
     mut aheader: *mut dc_aheader_t,
-    mut name: *const libc::c_char,
-    mut value: *const libc::c_char,
+    name: *const libc::c_char,
+    value: *const libc::c_char,
 ) -> libc::c_int {
     if strcasecmp(name, b"addr\x00" as *const u8 as *const libc::c_char) == 0 {
         if value.is_null() || 0 == dc_may_be_valid_addr(value) || !(*aheader).addr.is_null() {
@@ -232,7 +232,7 @@ unsafe fn add_attribute(
     0
 }
 
-pub unsafe fn dc_aheader_render(mut aheader: *const dc_aheader_t) -> *mut libc::c_char {
+pub unsafe fn dc_aheader_render(aheader: *const dc_aheader_t) -> *mut libc::c_char {
     let mut success: bool = false;
     let mut keybase64_wrapped: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut ret: dc_strbuilder_t = dc_strbuilder_t {
diff --git a/src/dc_apeerstate.rs b/src/dc_apeerstate.rs
index ef538d5ee..d46477dbf 100644
--- a/src/dc_apeerstate.rs
+++ b/src/dc_apeerstate.rs
@@ -44,7 +44,7 @@ pub unsafe fn dc_apeerstate_new<'a>(context: &'a dc_context_t) -> *mut dc_apeers
     peerstate
 }
 
-pub unsafe fn dc_apeerstate_unref(mut peerstate: *mut dc_apeerstate_t) {
+pub unsafe fn dc_apeerstate_unref(peerstate: *mut dc_apeerstate_t) {
     dc_apeerstate_empty(peerstate);
     free(peerstate as *mut libc::c_void);
 }
@@ -81,8 +81,8 @@ unsafe fn dc_apeerstate_empty(mut peerstate: *mut dc_apeerstate_t) {
 // TODO should return bool /rtn
 pub unsafe fn dc_apeerstate_init_from_header(
     mut peerstate: *mut dc_apeerstate_t,
-    mut header: *const dc_aheader_t,
-    mut message_time: time_t,
+    header: *const dc_aheader_t,
+    message_time: time_t,
 ) -> libc::c_int {
     if peerstate.is_null() || header.is_null() {
         return 0i32;
@@ -154,8 +154,8 @@ pub unsafe fn dc_apeerstate_recalc_fingerprint(mut peerstate: *mut dc_apeerstate
 // TODO should return bool /rtn
 pub unsafe extern "C" fn dc_apeerstate_init_from_gossip(
     mut peerstate: *mut dc_apeerstate_t,
-    mut gossip_header: *const dc_aheader_t,
-    mut message_time: time_t,
+    gossip_header: *const dc_aheader_t,
+    message_time: time_t,
 ) -> libc::c_int {
     if peerstate.is_null() || gossip_header.is_null() {
         return 0i32;
@@ -174,7 +174,7 @@ pub unsafe extern "C" fn dc_apeerstate_init_from_gossip(
 // TODO should return bool /rtn
 pub unsafe fn dc_apeerstate_degrade_encryption(
     mut peerstate: *mut dc_apeerstate_t,
-    mut message_time: time_t,
+    message_time: time_t,
 ) -> libc::c_int {
     if peerstate.is_null() {
         return 0i32;
@@ -191,8 +191,8 @@ pub unsafe fn dc_apeerstate_degrade_encryption(
 
 pub unsafe fn dc_apeerstate_apply_header(
     mut peerstate: *mut dc_apeerstate_t,
-    mut header: *const dc_aheader_t,
-    mut message_time: time_t,
+    header: *const dc_aheader_t,
+    message_time: time_t,
 ) {
     if peerstate.is_null()
         || header.is_null()
@@ -229,8 +229,8 @@ pub unsafe fn dc_apeerstate_apply_header(
 
 pub unsafe fn dc_apeerstate_apply_gossip(
     mut peerstate: *mut dc_apeerstate_t,
-    mut gossip_header: *const dc_aheader_t,
-    mut message_time: time_t,
+    gossip_header: *const dc_aheader_t,
+    message_time: time_t,
 ) {
     if peerstate.is_null()
         || gossip_header.is_null()
@@ -256,8 +256,8 @@ pub unsafe fn dc_apeerstate_apply_gossip(
 }
 
 pub unsafe fn dc_apeerstate_render_gossip_header(
-    mut peerstate: *const dc_apeerstate_t,
-    mut min_verified: libc::c_int,
+    peerstate: *const dc_apeerstate_t,
+    min_verified: libc::c_int,
 ) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut autocryptheader: *mut dc_aheader_t = dc_aheader_new();
@@ -272,8 +272,8 @@ pub unsafe fn dc_apeerstate_render_gossip_header(
 }
 
 pub unsafe fn dc_apeerstate_peek_key(
-    mut peerstate: *const dc_apeerstate_t,
-    mut min_verified: libc::c_int,
+    peerstate: *const dc_apeerstate_t,
+    min_verified: libc::c_int,
 ) -> *mut dc_key_t {
     if peerstate.is_null()
         || !(*peerstate).public_key.is_null()
@@ -300,9 +300,9 @@ pub unsafe fn dc_apeerstate_peek_key(
 // TODO should return bool /rtn
 pub unsafe fn dc_apeerstate_set_verified(
     mut peerstate: *mut dc_apeerstate_t,
-    mut which_key: libc::c_int,
-    mut fingerprint: *const libc::c_char,
-    mut verified: libc::c_int,
+    which_key: libc::c_int,
+    fingerprint: *const libc::c_char,
+    verified: libc::c_int,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     if !(peerstate.is_null() || which_key != 0i32 && which_key != 1i32 || verified != 2i32) {
@@ -335,9 +335,9 @@ pub unsafe fn dc_apeerstate_set_verified(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_apeerstate_load_by_addr(
-    mut peerstate: *mut dc_apeerstate_t,
-    mut sql: &dc_sqlite3_t,
-    mut addr: *const libc::c_char,
+    peerstate: *mut dc_apeerstate_t,
+    sql: &dc_sqlite3_t,
+    addr: *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;
@@ -361,7 +361,7 @@ pub unsafe fn dc_apeerstate_load_by_addr(
 
 unsafe fn dc_apeerstate_set_from_stmt(
     mut peerstate: *mut dc_apeerstate_t,
-    mut stmt: *mut sqlite3_stmt,
+    stmt: *mut sqlite3_stmt,
 ) {
     (*peerstate).addr = dc_strdup(sqlite3_column_text(stmt, 0i32) as *mut libc::c_char);
     (*peerstate).last_seen = sqlite3_column_int64(stmt, 1i32) as time_t;
@@ -390,9 +390,9 @@ unsafe fn dc_apeerstate_set_from_stmt(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_apeerstate_load_by_fingerprint(
-    mut peerstate: *mut dc_apeerstate_t,
-    mut sql: &dc_sqlite3_t,
-    mut fingerprint: *const libc::c_char,
+    peerstate: *mut dc_apeerstate_t,
+    sql: &dc_sqlite3_t,
+    fingerprint: *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;
@@ -418,11 +418,11 @@ pub unsafe fn dc_apeerstate_load_by_fingerprint(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_apeerstate_save_to_db(
-    mut peerstate: *const dc_apeerstate_t,
-    mut sql: &dc_sqlite3_t,
-    mut create: libc::c_int,
+    peerstate: *const dc_apeerstate_t,
+    sql: &dc_sqlite3_t,
+    create: libc::c_int,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if peerstate.is_null() || (*peerstate).addr.is_null() {
@@ -555,8 +555,8 @@ pub unsafe fn dc_apeerstate_save_to_db(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_apeerstate_has_verified_key(
-    mut peerstate: *const dc_apeerstate_t,
-    mut fingerprints: *const dc_hash_t,
+    peerstate: *const dc_apeerstate_t,
+    fingerprints: *const dc_hash_t,
 ) -> libc::c_int {
     if peerstate.is_null() || fingerprints.is_null() {
         return 0i32;
diff --git a/src/dc_array.rs b/src/dc_array.rs
index cf03b0b60..f8ecf90a2 100644
--- a/src/dc_array.rs
+++ b/src/dc_array.rs
@@ -34,7 +34,7 @@ pub unsafe fn dc_array_unref(mut array: *mut dc_array_t) {
     free(array as *mut libc::c_void);
 }
 
-pub unsafe fn dc_array_free_ptr(mut array: *mut dc_array_t) {
+pub unsafe fn dc_array_free_ptr(array: *mut dc_array_t) {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint {
         return;
     }
@@ -52,12 +52,12 @@ pub unsafe fn dc_array_free_ptr(mut array: *mut dc_array_t) {
     }
 }
 
-pub unsafe fn dc_array_add_uint(mut array: *mut dc_array_t, mut item: uintptr_t) {
+pub unsafe fn dc_array_add_uint(mut array: *mut dc_array_t, item: uintptr_t) {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint {
         return;
     }
     if (*array).count == (*array).allocated {
-        let mut newsize = (*array).allocated.wrapping_mul(2).wrapping_add(10);
+        let newsize = (*array).allocated.wrapping_mul(2).wrapping_add(10);
         (*array).array = realloc(
             (*array).array as *mut libc::c_void,
             (newsize).wrapping_mul(::std::mem::size_of::<uintptr_t>()),
@@ -71,29 +71,29 @@ pub unsafe fn dc_array_add_uint(mut array: *mut dc_array_t, mut item: uintptr_t)
     (*array).count = (*array).count.wrapping_add(1);
 }
 
-pub unsafe fn dc_array_add_id(mut array: *mut dc_array_t, mut item: uint32_t) {
+pub unsafe fn dc_array_add_id(array: *mut dc_array_t, item: uint32_t) {
     dc_array_add_uint(array, item as uintptr_t);
 }
 
-pub unsafe fn dc_array_add_ptr(mut array: *mut dc_array_t, mut item: *mut libc::c_void) {
+pub unsafe fn dc_array_add_ptr(array: *mut dc_array_t, item: *mut libc::c_void) {
     dc_array_add_uint(array, item as uintptr_t);
 }
 
-pub unsafe fn dc_array_get_cnt(mut array: *const dc_array_t) -> size_t {
+pub unsafe fn dc_array_get_cnt(array: *const dc_array_t) -> size_t {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint {
         return 0i32 as size_t;
     }
     (*array).count
 }
 
-pub unsafe fn dc_array_get_uint(mut array: *const dc_array_t, mut index: size_t) -> uintptr_t {
+pub unsafe fn dc_array_get_uint(array: *const dc_array_t, index: size_t) -> uintptr_t {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint || index >= (*array).count {
         return 0i32 as uintptr_t;
     }
     *(*array).array.offset(index as isize)
 }
 
-pub unsafe fn dc_array_get_id(mut array: *const dc_array_t, mut index: size_t) -> uint32_t {
+pub unsafe fn dc_array_get_id(array: *const dc_array_t, index: size_t) -> uint32_t {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint || index >= (*array).count {
         return 0i32 as uint32_t;
     }
@@ -103,20 +103,14 @@ pub unsafe fn dc_array_get_id(mut array: *const dc_array_t, mut index: size_t) -
     *(*array).array.offset(index as isize) as uint32_t
 }
 
-pub unsafe fn dc_array_get_ptr(
-    mut array: *const dc_array_t,
-    mut index: size_t,
-) -> *mut libc::c_void {
+pub unsafe fn dc_array_get_ptr(array: *const dc_array_t, index: size_t) -> *mut libc::c_void {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint || index >= (*array).count {
         return 0 as *mut libc::c_void;
     }
     *(*array).array.offset(index as isize) as *mut libc::c_void
 }
 
-pub unsafe fn dc_array_get_latitude(
-    mut array: *const dc_array_t,
-    mut index: size_t,
-) -> libc::c_double {
+pub unsafe fn dc_array_get_latitude(array: *const dc_array_t, index: size_t) -> libc::c_double {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -128,10 +122,7 @@ pub unsafe fn dc_array_get_latitude(
     (*(*(*array).array.offset(index as isize) as *mut _dc_location)).latitude
 }
 
-pub unsafe fn dc_array_get_longitude(
-    mut array: *const dc_array_t,
-    mut index: size_t,
-) -> libc::c_double {
+pub unsafe fn dc_array_get_longitude(array: *const dc_array_t, index: size_t) -> libc::c_double {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -143,10 +134,7 @@ pub unsafe fn dc_array_get_longitude(
     (*(*(*array).array.offset(index as isize) as *mut _dc_location)).longitude
 }
 
-pub unsafe fn dc_array_get_accuracy(
-    mut array: *const dc_array_t,
-    mut index: size_t,
-) -> libc::c_double {
+pub unsafe fn dc_array_get_accuracy(array: *const dc_array_t, index: size_t) -> libc::c_double {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -158,7 +146,7 @@ pub unsafe fn dc_array_get_accuracy(
     (*(*(*array).array.offset(index as isize) as *mut _dc_location)).accuracy
 }
 
-pub unsafe fn dc_array_get_timestamp(mut array: *const dc_array_t, mut index: size_t) -> time_t {
+pub unsafe fn dc_array_get_timestamp(array: *const dc_array_t, index: size_t) -> time_t {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -170,7 +158,7 @@ pub unsafe fn dc_array_get_timestamp(mut array: *const dc_array_t, mut index: si
     (*(*(*array).array.offset(index as isize) as *mut _dc_location)).timestamp
 }
 
-pub unsafe fn dc_array_get_chat_id(mut array: *const dc_array_t, mut index: size_t) -> uint32_t {
+pub unsafe fn dc_array_get_chat_id(array: *const dc_array_t, index: size_t) -> uint32_t {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -182,7 +170,7 @@ pub unsafe fn dc_array_get_chat_id(mut array: *const dc_array_t, mut index: size
     (*(*(*array).array.offset(index as isize) as *mut _dc_location)).chat_id
 }
 
-pub unsafe fn dc_array_get_contact_id(mut array: *const dc_array_t, mut index: size_t) -> uint32_t {
+pub unsafe fn dc_array_get_contact_id(array: *const dc_array_t, index: size_t) -> uint32_t {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -194,7 +182,7 @@ pub unsafe fn dc_array_get_contact_id(mut array: *const dc_array_t, mut index: s
     (*(*(*array).array.offset(index as isize) as *mut _dc_location)).contact_id
 }
 
-pub unsafe fn dc_array_get_msg_id(mut array: *const dc_array_t, mut index: size_t) -> uint32_t {
+pub unsafe fn dc_array_get_msg_id(array: *const dc_array_t, index: size_t) -> uint32_t {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -206,10 +194,7 @@ pub unsafe fn dc_array_get_msg_id(mut array: *const dc_array_t, mut index: size_
     (*(*(*array).array.offset(index as isize) as *mut _dc_location)).msg_id
 }
 
-pub unsafe fn dc_array_get_marker(
-    mut array: *const dc_array_t,
-    mut index: size_t,
-) -> *mut libc::c_char {
+pub unsafe fn dc_array_get_marker(array: *const dc_array_t, index: size_t) -> *mut libc::c_char {
     if array.is_null()
         || (*array).magic != 0xa11aai32 as libc::c_uint
         || index >= (*array).count
@@ -246,16 +231,16 @@ pub unsafe fn dc_array_is_independent(array: *const dc_array_t, index: size_t) -
 
 // TODO should return bool /rtn
 pub unsafe fn dc_array_search_id(
-    mut array: *const dc_array_t,
-    mut needle: uint32_t,
-    mut ret_index: *mut size_t,
+    array: *const dc_array_t,
+    needle: uint32_t,
+    ret_index: *mut size_t,
 ) -> libc::c_int {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint {
         return 0i32;
     }
-    let mut data: *mut uintptr_t = (*array).array;
+    let data: *mut uintptr_t = (*array).array;
     let mut i: size_t = 0;
-    let mut cnt: size_t = (*array).count;
+    let cnt: size_t = (*array).count;
     while i < cnt {
         if *data.offset(i as isize) == needle as size_t {
             if !ret_index.is_null() {
@@ -268,7 +253,7 @@ pub unsafe fn dc_array_search_id(
     0
 }
 
-pub unsafe fn dc_array_get_raw(mut array: *const dc_array_t) -> *const uintptr_t {
+pub unsafe fn dc_array_get_raw(array: *const dc_array_t) -> *const uintptr_t {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint {
         return 0 as *const uintptr_t;
     }
@@ -280,8 +265,8 @@ pub unsafe fn dc_array_new(initsize: size_t) -> *mut dc_array_t {
 }
 
 pub unsafe extern "C" fn dc_array_new_typed(
-    mut type_0: libc::c_int,
-    mut initsize: size_t,
+    type_0: libc::c_int,
+    initsize: size_t,
 ) -> *mut dc_array_t {
     let mut array: *mut dc_array_t;
     array = calloc(1, ::std::mem::size_of::<dc_array_t>()) as *mut dc_array_t;
@@ -310,7 +295,7 @@ pub unsafe fn dc_array_empty(mut array: *mut dc_array_t) {
     (*array).count = 0i32 as size_t;
 }
 
-pub unsafe fn dc_array_duplicate(mut array: *const dc_array_t) -> *mut dc_array_t {
+pub unsafe fn dc_array_duplicate(array: *const dc_array_t) -> *mut dc_array_t {
     let mut ret: *mut dc_array_t;
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint {
         return 0 as *mut dc_array_t;
@@ -327,7 +312,7 @@ pub unsafe fn dc_array_duplicate(mut array: *const dc_array_t) -> *mut dc_array_
     ret
 }
 
-pub unsafe fn dc_array_sort_ids(mut array: *mut dc_array_t) {
+pub unsafe fn dc_array_sort_ids(array: *mut dc_array_t) {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint || (*array).count <= 1 {
         return;
     }
@@ -339,12 +324,9 @@ pub unsafe fn dc_array_sort_ids(mut array: *mut dc_array_t) {
     );
 }
 
-unsafe extern "C" fn cmp_intptr_t(
-    mut p1: *const libc::c_void,
-    mut p2: *const libc::c_void,
-) -> libc::c_int {
-    let mut v1: uintptr_t = *(p1 as *mut uintptr_t);
-    let mut v2: uintptr_t = *(p2 as *mut uintptr_t);
+unsafe extern "C" fn cmp_intptr_t(p1: *const libc::c_void, p2: *const libc::c_void) -> libc::c_int {
+    let v1: uintptr_t = *(p1 as *mut uintptr_t);
+    let v2: uintptr_t = *(p2 as *mut uintptr_t);
     return if v1 < v2 {
         -1i32
     } else if v1 > v2 {
@@ -354,7 +336,7 @@ unsafe extern "C" fn cmp_intptr_t(
     };
 }
 
-pub unsafe fn dc_array_sort_strings(mut array: *mut dc_array_t) {
+pub unsafe fn dc_array_sort_strings(array: *mut dc_array_t) {
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint || (*array).count <= 1 {
         return;
     }
@@ -367,20 +349,20 @@ pub unsafe fn dc_array_sort_strings(mut array: *mut dc_array_t) {
 }
 
 unsafe extern "C" fn cmp_strings_t(
-    mut p1: *const libc::c_void,
-    mut p2: *const libc::c_void,
+    p1: *const libc::c_void,
+    p2: *const libc::c_void,
 ) -> libc::c_int {
-    let mut v1: *const libc::c_char = *(p1 as *mut *const libc::c_char);
-    let mut v2: *const libc::c_char = *(p2 as *mut *const libc::c_char);
+    let v1: *const libc::c_char = *(p1 as *mut *const libc::c_char);
+    let v2: *const libc::c_char = *(p2 as *mut *const libc::c_char);
 
     strcmp(v1, v2)
 }
 
 pub unsafe fn dc_array_get_string(
-    mut array: *const dc_array_t,
-    mut sep: *const libc::c_char,
+    array: *const dc_array_t,
+    sep: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut ret: *mut libc::c_char;
+    let ret: *mut libc::c_char;
     if array.is_null() || (*array).magic != 0xa11aai32 as libc::c_uint || sep.is_null() {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
     }
@@ -410,13 +392,10 @@ pub unsafe fn dc_array_get_string(
     ret
 }
 
-pub unsafe fn dc_arr_to_string(
-    mut arr: *const uint32_t,
-    mut cnt: libc::c_int,
-) -> *mut libc::c_char {
+pub unsafe fn dc_arr_to_string(arr: *const uint32_t, cnt: libc::c_int) -> *mut libc::c_char {
     /* return comma-separated value-string from integer array */
-    let mut ret: *mut libc::c_char;
-    let mut sep: *const libc::c_char = b",\x00" as *const u8 as *const libc::c_char;
+    let ret: *mut libc::c_char;
+    let sep: *const libc::c_char = b",\x00" as *const u8 as *const libc::c_char;
     if arr.is_null() || cnt <= 0i32 {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
     }
diff --git a/src/dc_chat.rs b/src/dc_chat.rs
index 24bba36c9..e51340a8f 100644
--- a/src/dc_chat.rs
+++ b/src/dc_chat.rs
@@ -32,14 +32,11 @@ pub struct dc_chat_t<'a> {
 }
 
 // handle chats
-pub unsafe fn dc_create_chat_by_msg_id(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-) -> uint32_t {
+pub unsafe fn dc_create_chat_by_msg_id(context: &dc_context_t, msg_id: uint32_t) -> uint32_t {
     let mut chat_id: uint32_t = 0i32 as uint32_t;
     let mut send_event: libc::c_int = 0i32;
-    let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
-    let mut chat: *mut dc_chat_t = dc_chat_new(context);
+    let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
+    let chat: *mut dc_chat_t = dc_chat_new(context);
     if !(0 == dc_msg_load_from_db(msg, context, msg_id)
         || 0 == dc_chat_load_from_db(chat, (*msg).chat_id)
         || (*chat).id <= 9i32 as libc::c_uint)
@@ -115,16 +112,12 @@ pub unsafe fn dc_chat_empty(mut chat: *mut dc_chat_t) {
     dc_param_set_packed((*chat).param, 0 as *const libc::c_char);
 }
 
-pub unsafe fn dc_unblock_chat(mut context: &dc_context_t, mut chat_id: uint32_t) {
+pub unsafe fn dc_unblock_chat(context: &dc_context_t, chat_id: uint32_t) {
     dc_block_chat(context, chat_id, 0i32);
 }
 
-pub unsafe fn dc_block_chat(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut new_blocking: libc::c_int,
-) {
-    let mut stmt: *mut sqlite3_stmt;
+pub unsafe fn dc_block_chat(context: &dc_context_t, chat_id: uint32_t, new_blocking: libc::c_int) {
+    let stmt: *mut sqlite3_stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -137,7 +130,7 @@ pub unsafe fn dc_block_chat(
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_chat_load_from_db(mut chat: *mut dc_chat_t, mut chat_id: uint32_t) -> libc::c_int {
+pub unsafe fn dc_chat_load_from_db(chat: *mut dc_chat_t, chat_id: uint32_t) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !(chat.is_null() || (*chat).magic != 0xc4a7c4a7u32) {
@@ -161,7 +154,7 @@ pub unsafe fn dc_chat_load_from_db(mut chat: *mut dc_chat_t, mut chat_id: uint32
     success
 }
 
-unsafe fn set_from_stmt(mut chat: *mut dc_chat_t, mut row: *mut sqlite3_stmt) -> libc::c_int {
+unsafe fn set_from_stmt(mut chat: *mut dc_chat_t, row: *mut sqlite3_stmt) -> libc::c_int {
     let mut row_offset: libc::c_int = 0i32;
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 || row.is_null() {
         return 0i32;
@@ -204,7 +197,7 @@ unsafe fn set_from_stmt(mut chat: *mut dc_chat_t, mut row: *mut sqlite3_stmt) ->
         (*chat).name = dc_stock_str((*chat).context, 8i32)
     } else if (*chat).id == 6i32 as libc::c_uint {
         free((*chat).name as *mut libc::c_void);
-        let mut tempname: *mut libc::c_char = dc_stock_str((*chat).context, 40i32);
+        let tempname: *mut libc::c_char = dc_stock_str((*chat).context, 40i32);
         (*chat).name = dc_mprintf(
             b"%s (%i)\x00" as *const u8 as *const libc::c_char,
             tempname,
@@ -222,8 +215,8 @@ unsafe fn set_from_stmt(mut chat: *mut dc_chat_t, mut row: *mut sqlite3_stmt) ->
 }
 
 pub unsafe fn dc_create_chat_by_contact_id(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    contact_id: uint32_t,
 ) -> uint32_t {
     let mut chat_id: uint32_t = 0i32 as uint32_t;
     let mut chat_blocked: libc::c_int = 0i32;
@@ -269,16 +262,16 @@ pub unsafe fn dc_create_chat_by_contact_id(
 }
 
 pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-    mut create_blocked: libc::c_int,
-    mut ret_chat_id: *mut uint32_t,
-    mut ret_chat_blocked: *mut libc::c_int,
+    context: &dc_context_t,
+    contact_id: uint32_t,
+    create_blocked: libc::c_int,
+    ret_chat_id: *mut uint32_t,
+    ret_chat_blocked: *mut libc::c_int,
 ) {
     let mut chat_id: uint32_t = 0i32 as uint32_t;
     let mut chat_blocked: libc::c_int = 0i32;
-    let mut contact: *mut dc_contact_t;
-    let mut chat_name: *mut libc::c_char;
+    let contact: *mut dc_contact_t;
+    let chat_name: *mut libc::c_char;
     let mut q: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !ret_chat_id.is_null() {
@@ -376,13 +369,13 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
 }
 
 pub unsafe fn dc_lookup_real_nchat_by_contact_id(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-    mut ret_chat_id: *mut uint32_t,
-    mut ret_chat_blocked: *mut libc::c_int,
+    context: &dc_context_t,
+    contact_id: uint32_t,
+    ret_chat_id: *mut uint32_t,
+    ret_chat_blocked: *mut libc::c_int,
 ) {
     /* checks for "real" chats or self-chat */
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     if !ret_chat_id.is_null() {
         *ret_chat_id = 0i32 as uint32_t
     }
@@ -411,8 +404,8 @@ pub unsafe fn dc_lookup_real_nchat_by_contact_id(
 }
 
 pub unsafe fn dc_get_chat_id_by_contact_id(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    contact_id: uint32_t,
 ) -> uint32_t {
     let mut chat_id: uint32_t = 0i32 as uint32_t;
     let mut chat_id_blocked: libc::c_int = 0i32;
@@ -425,15 +418,15 @@ pub unsafe fn dc_get_chat_id_by_contact_id(
 }
 
 pub unsafe fn dc_prepare_msg<'a>(
-    mut context: &'a dc_context_t,
-    mut chat_id: uint32_t,
+    context: &'a dc_context_t,
+    chat_id: uint32_t,
     mut msg: *mut dc_msg_t<'a>,
 ) -> uint32_t {
     if msg.is_null() || chat_id <= 9i32 as libc::c_uint {
         return 0i32 as uint32_t;
     }
     (*msg).state = 18i32;
-    let mut msg_id: uint32_t = prepare_msg_common(context, chat_id, msg);
+    let msg_id: uint32_t = prepare_msg_common(context, chat_id, msg);
     (context.cb)(
         context,
         Event::MSGS_CHANGED,
@@ -444,11 +437,11 @@ pub unsafe fn dc_prepare_msg<'a>(
 }
 
 unsafe fn prepare_msg_common<'a>(
-    mut context: &'a dc_context_t,
-    mut chat_id: uint32_t,
+    context: &'a dc_context_t,
+    chat_id: uint32_t,
     mut msg: *mut dc_msg_t<'a>,
 ) -> uint32_t {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut chat: *mut dc_chat_t = 0 as *mut dc_chat_t;
     (*msg).id = 0i32 as uint32_t;
@@ -544,14 +537,14 @@ unsafe fn prepare_msg_common<'a>(
 }
 
 unsafe fn prepare_msg_raw(
-    mut context: &dc_context_t,
-    mut chat: *mut dc_chat_t,
-    mut msg: *const dc_msg_t,
-    mut timestamp: time_t,
+    context: &dc_context_t,
+    chat: *mut dc_chat_t,
+    msg: *const dc_msg_t,
+    timestamp: time_t,
 ) -> uint32_t {
     let mut do_guarantee_e2ee: libc::c_int;
-    let mut e2ee_enabled: libc::c_int;
-    let mut current_block: u64;
+    let e2ee_enabled: libc::c_int;
+    let current_block: u64;
     let mut parent_rfc724_mid: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut parent_references: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut parent_in_reply_to: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -580,7 +573,7 @@ unsafe fn prepare_msg_raw(
             b"Cannot send message; self not in group.\x00" as *const u8 as *const libc::c_char,
         );
     } else {
-        let mut from: *mut libc::c_char = dc_sqlite3_get_config(
+        let from: *mut libc::c_char = dc_sqlite3_get_config(
             context,
             &context.sql.clone().read().unwrap(),
             b"configured_addr\x00" as *const u8 as *const libc::c_char,
@@ -670,8 +663,7 @@ unsafe fn prepare_msg_raw(
                                 can_encrypt = 0i32;
                                 all_mutual = 0i32
                             } else {
-                                let mut prefer_encrypted: libc::c_int =
-                                    sqlite3_column_int(stmt, 0i32);
+                                let prefer_encrypted: libc::c_int = sqlite3_column_int(stmt, 0i32);
                                 if prefer_encrypted != 1i32 {
                                     dc_log_info(
                                         context,
@@ -722,7 +714,7 @@ unsafe fn prepare_msg_raw(
                             new_in_reply_to = dc_strdup(parent_rfc724_mid)
                         }
                         if !parent_references.is_null() {
-                            let mut space: *mut libc::c_char;
+                            let space: *mut libc::c_char;
                             space = strchr(parent_references, ' ' as i32);
                             if !space.is_null() {
                                 *space = 0i32 as libc::c_char
@@ -870,10 +862,10 @@ unsafe fn prepare_msg_raw(
 
 // TODO should return bool /rtn
 unsafe fn get_parent_mime_headers(
-    mut chat: *const dc_chat_t,
-    mut parent_rfc724_mid: *mut *mut libc::c_char,
-    mut parent_in_reply_to: *mut *mut libc::c_char,
-    mut parent_references: *mut *mut libc::c_char,
+    chat: *const dc_chat_t,
+    parent_rfc724_mid: *mut *mut libc::c_char,
+    parent_in_reply_to: *mut *mut libc::c_char,
+    parent_references: *mut *mut libc::c_char,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -920,7 +912,7 @@ unsafe fn get_parent_mime_headers(
     success
 }
 
-pub unsafe fn dc_chat_is_self_talk(mut chat: *const dc_chat_t) -> libc::c_int {
+pub unsafe fn dc_chat_is_self_talk(chat: *const dc_chat_t) -> libc::c_int {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return 0i32;
     }
@@ -937,14 +929,14 @@ unsafe fn last_msg_in_chat_encrypted(
     chat_id: uint32_t,
 ) -> libc::c_int {
     let mut last_is_encrypted: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt =
+    let  stmt: *mut sqlite3_stmt =
         dc_sqlite3_prepare(
             context,sql,
                            b"SELECT param  FROM msgs  WHERE timestamp=(SELECT MAX(timestamp) FROM msgs WHERE chat_id=?)  ORDER BY id DESC;\x00"
                                as *const u8 as *const libc::c_char);
     sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
     if sqlite3_step(stmt) == 100i32 {
-        let mut msg_param: *mut dc_param_t = dc_param_new();
+        let msg_param: *mut dc_param_t = dc_param_new();
         dc_param_set_packed(
             msg_param,
             sqlite3_column_text(stmt, 0i32) as *mut libc::c_char,
@@ -959,9 +951,9 @@ unsafe fn last_msg_in_chat_encrypted(
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_chat_update_param(mut chat: *mut dc_chat_t) -> libc::c_int {
-    let mut success: libc::c_int;
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+pub unsafe fn dc_chat_update_param(chat: *mut dc_chat_t) -> libc::c_int {
+    let success: libc::c_int;
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         (*chat).context,
         &mut (*chat).context.sql.clone().read().unwrap(),
         b"UPDATE chats SET param=? WHERE id=?\x00" as *const u8 as *const libc::c_char,
@@ -978,14 +970,14 @@ pub unsafe fn dc_chat_update_param(mut chat: *mut dc_chat_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_is_contact_in_chat(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    contact_id: uint32_t,
 ) -> libc::c_int {
     /* this function works for group and for normal chats, however, it is more useful for group chats.
     DC_CONTACT_ID_SELF may be used to check, if the user itself is in a group chat (DC_CONTACT_ID_SELF is not added to normal chats) */
-    let mut ret: libc::c_int;
-    let mut stmt: *mut sqlite3_stmt;
+    let ret: libc::c_int;
+    let stmt: *mut sqlite3_stmt;
 
     stmt = dc_sqlite3_prepare(
         context,
@@ -1005,8 +997,8 @@ pub unsafe fn dc_is_contact_in_chat(
     ret
 }
 
-pub unsafe fn dc_unarchive_chat(mut context: &dc_context_t, mut chat_id: uint32_t) {
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+pub unsafe fn dc_unarchive_chat(context: &dc_context_t, chat_id: uint32_t) {
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE chats SET archived=0 WHERE id=?\x00" as *const u8 as *const libc::c_char,
@@ -1017,9 +1009,9 @@ pub unsafe fn dc_unarchive_chat(mut context: &dc_context_t, mut chat_id: uint32_
 }
 
 pub unsafe fn dc_send_msg<'a>(
-    mut context: &'a dc_context_t,
-    mut chat_id: uint32_t,
-    mut msg: *mut dc_msg_t<'a>,
+    context: &'a dc_context_t,
+    chat_id: uint32_t,
+    msg: *mut dc_msg_t<'a>,
 ) -> uint32_t {
     if msg.is_null() {
         return 0i32 as uint32_t;
@@ -1049,17 +1041,17 @@ pub unsafe fn dc_send_msg<'a>(
     }
 
     if 0 == chat_id {
-        let mut forwards: *mut libc::c_char =
+        let forwards: *mut libc::c_char =
             dc_param_get((*msg).param, 'P' as i32, 0 as *const libc::c_char);
         if !forwards.is_null() {
             let mut p: *mut libc::c_char = forwards;
             while 0 != *p {
-                let mut id: int32_t = strtol(p, &mut p, 10i32) as int32_t;
+                let id: int32_t = strtol(p, &mut p, 10i32) as int32_t;
                 if 0 == id {
                     // avoid hanging if user tampers with db
                     break;
                 } else {
-                    let mut copy: *mut dc_msg_t = dc_get_msg(context, id as uint32_t);
+                    let copy: *mut dc_msg_t = dc_get_msg(context, id as uint32_t);
                     if !copy.is_null() {
                         dc_send_msg(context, 0i32 as uint32_t, copy);
                     }
@@ -1076,9 +1068,9 @@ pub unsafe fn dc_send_msg<'a>(
 }
 
 pub unsafe fn dc_send_text_msg(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut text_to_send: *const libc::c_char,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    text_to_send: *const libc::c_char,
 ) -> uint32_t {
     let mut msg: *mut dc_msg_t = dc_msg_new(context, 10i32);
     let mut ret: uint32_t = 0i32 as uint32_t;
@@ -1090,11 +1082,7 @@ pub unsafe fn dc_send_text_msg(
     ret
 }
 
-pub unsafe fn dc_set_draft(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut msg: *mut dc_msg_t,
-) {
+pub unsafe fn dc_set_draft(context: &dc_context_t, chat_id: uint32_t, msg: *mut dc_msg_t) {
     if chat_id <= 9i32 as libc::c_uint {
         return;
     }
@@ -1110,15 +1098,15 @@ pub unsafe fn dc_set_draft(
 
 // TODO should return bool /rtn
 unsafe fn set_draft_raw(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut msg: *mut dc_msg_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    msg: *mut dc_msg_t,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     // similar to as dc_set_draft() but does not emit an event
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut prev_draft_msg_id: uint32_t;
+    let prev_draft_msg_id: uint32_t;
     let mut sth_changed: libc::c_int = 0i32;
     prev_draft_msg_id = get_draft_msg_id(context, chat_id);
     if 0 != prev_draft_msg_id {
@@ -1194,9 +1182,9 @@ unsafe fn set_draft_raw(
     sth_changed
 }
 
-unsafe fn get_draft_msg_id(mut context: &dc_context_t, mut chat_id: uint32_t) -> uint32_t {
+unsafe fn get_draft_msg_id(context: &dc_context_t, chat_id: uint32_t) -> uint32_t {
     let mut draft_msg_id: uint32_t = 0i32 as uint32_t;
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"SELECT id FROM msgs WHERE chat_id=? AND state=?;\x00" as *const u8 as *const libc::c_char,
@@ -1210,9 +1198,9 @@ unsafe fn get_draft_msg_id(mut context: &dc_context_t, mut chat_id: uint32_t) ->
     draft_msg_id
 }
 
-pub unsafe fn dc_get_draft(mut context: &dc_context_t, mut chat_id: uint32_t) -> *mut dc_msg_t {
-    let mut draft_msg_id: uint32_t;
-    let mut draft_msg: *mut dc_msg_t;
+pub unsafe fn dc_get_draft(context: &dc_context_t, chat_id: uint32_t) -> *mut dc_msg_t {
+    let draft_msg_id: uint32_t;
+    let draft_msg: *mut dc_msg_t;
     if chat_id <= 9i32 as libc::c_uint {
         return 0 as *mut dc_msg_t;
     }
@@ -1230,23 +1218,23 @@ pub unsafe fn dc_get_draft(mut context: &dc_context_t, mut chat_id: uint32_t) ->
 }
 
 pub unsafe fn dc_get_chat_msgs(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut flags: uint32_t,
-    mut marker1before: uint32_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    flags: uint32_t,
+    marker1before: uint32_t,
 ) -> *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(512i32 as size_t);
+    let ret: *mut dc_array_t = dc_array_new(512i32 as size_t);
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut curr_id: uint32_t;
     let mut curr_local_timestamp: time_t;
     let mut curr_day: libc::c_int;
     let mut last_day: libc::c_int = 0i32;
-    let mut cnv_to_local: libc::c_long = dc_gm2local_offset();
+    let cnv_to_local: libc::c_long = dc_gm2local_offset();
     if !ret.is_null() {
         if chat_id == 1i32 as libc::c_uint {
-            let mut show_emails: libc::c_int = dc_sqlite3_get_config_int(
+            let show_emails: libc::c_int = dc_sqlite3_get_config_int(
                 context,
                 &context.sql.clone().read().unwrap(),
                 b"show_emails\x00" as *const u8 as *const libc::c_char,
@@ -1300,9 +1288,9 @@ pub unsafe fn dc_get_chat_msgs(
     };
 }
 
-pub unsafe fn dc_get_msg_cnt(mut context: &dc_context_t, mut chat_id: uint32_t) -> libc::c_int {
+pub unsafe fn dc_get_msg_cnt(context: &dc_context_t, chat_id: uint32_t) -> libc::c_int {
     let mut ret: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -1317,12 +1305,9 @@ pub unsafe fn dc_get_msg_cnt(mut context: &dc_context_t, mut chat_id: uint32_t)
     ret
 }
 
-pub unsafe fn dc_get_fresh_msg_cnt(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-) -> libc::c_int {
+pub unsafe fn dc_get_fresh_msg_cnt(context: &dc_context_t, chat_id: uint32_t) -> libc::c_int {
     let mut ret: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -1337,8 +1322,8 @@ pub unsafe fn dc_get_fresh_msg_cnt(
     ret
 }
 
-pub unsafe fn dc_marknoticed_chat(mut context: &dc_context_t, mut chat_id: uint32_t) {
-    let mut check: *mut sqlite3_stmt;
+pub unsafe fn dc_marknoticed_chat(context: &dc_context_t, chat_id: uint32_t) {
+    let check: *mut sqlite3_stmt;
     let mut update: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
 
     check = dc_sqlite3_prepare(
@@ -1369,8 +1354,8 @@ pub unsafe fn dc_marknoticed_chat(mut context: &dc_context_t, mut chat_id: uint3
     sqlite3_finalize(update);
 }
 
-pub unsafe fn dc_marknoticed_all_chats(mut context: &dc_context_t) {
-    let mut check: *mut sqlite3_stmt;
+pub unsafe fn dc_marknoticed_all_chats(context: &dc_context_t) {
+    let check: *mut sqlite3_stmt;
     let mut update: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
 
     check = dc_sqlite3_prepare(
@@ -1398,14 +1383,14 @@ pub unsafe fn dc_marknoticed_all_chats(mut context: &dc_context_t) {
 }
 
 pub unsafe fn dc_get_chat_media(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut msg_type: libc::c_int,
-    mut msg_type2: libc::c_int,
-    mut msg_type3: libc::c_int,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    msg_type: libc::c_int,
+    msg_type2: libc::c_int,
+    msg_type3: libc::c_int,
 ) -> *mut dc_array_t {
-    let mut ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
-    let mut stmt: *mut sqlite3_stmt =
+    let ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
+    let  stmt: *mut sqlite3_stmt =
         dc_sqlite3_prepare(
             context,&context.sql.clone().read().unwrap(),
                            b"SELECT id FROM msgs WHERE chat_id=? AND (type=? OR type=? OR type=?) ORDER BY timestamp, id;\x00"
@@ -1438,18 +1423,18 @@ pub unsafe fn dc_get_chat_media(
 }
 
 pub unsafe fn dc_get_next_media(
-    mut context: &dc_context_t,
-    mut curr_msg_id: uint32_t,
-    mut dir: libc::c_int,
-    mut msg_type: libc::c_int,
-    mut msg_type2: libc::c_int,
-    mut msg_type3: libc::c_int,
+    context: &dc_context_t,
+    curr_msg_id: uint32_t,
+    dir: libc::c_int,
+    msg_type: libc::c_int,
+    msg_type2: libc::c_int,
+    msg_type3: libc::c_int,
 ) -> uint32_t {
     let mut ret_msg_id: uint32_t = 0i32 as uint32_t;
-    let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
+    let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let mut list: *mut dc_array_t = 0 as *mut dc_array_t;
     let mut i: libc::c_int;
-    let mut cnt: libc::c_int;
+    let cnt: libc::c_int;
 
     if !(0 == dc_msg_load_from_db(msg, context, curr_msg_id)) {
         list = dc_get_chat_media(
@@ -1490,16 +1475,12 @@ pub unsafe fn dc_get_next_media(
     ret_msg_id
 }
 
-pub unsafe fn dc_archive_chat(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut archive: libc::c_int,
-) {
+pub unsafe fn dc_archive_chat(context: &dc_context_t, chat_id: uint32_t, archive: libc::c_int) {
     if chat_id <= 9i32 as libc::c_uint || archive != 0i32 && archive != 1i32 {
         return;
     }
     if 0 != archive {
-        let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+        let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
             context,
             &context.sql.clone().read().unwrap(),
             b"UPDATE msgs SET state=13 WHERE chat_id=? AND state=10;\x00" as *const u8
@@ -1509,7 +1490,7 @@ pub unsafe fn dc_archive_chat(
         sqlite3_step(stmt);
         sqlite3_finalize(stmt);
     }
-    let mut stmt_0: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt_0: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE chats SET archived=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
@@ -1526,9 +1507,9 @@ pub unsafe fn dc_archive_chat(
     );
 }
 
-pub unsafe fn dc_delete_chat(mut context: &dc_context_t, mut chat_id: uint32_t) {
+pub unsafe fn dc_delete_chat(context: &dc_context_t, chat_id: uint32_t) {
     /* Up to 2017-11-02 deleting a group also implied leaving it, see above why we have changed this. */
-    let mut obj: *mut dc_chat_t = dc_chat_new(context);
+    let obj: *mut dc_chat_t = dc_chat_new(context);
     let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(chat_id <= 9i32 as libc::c_uint) {
         if !(0 == dc_chat_load_from_db(obj, chat_id)) {
@@ -1585,13 +1566,10 @@ pub unsafe fn dc_delete_chat(mut context: &dc_context_t, mut chat_id: uint32_t)
     sqlite3_free(q3 as *mut libc::c_void);
 }
 
-pub unsafe fn dc_get_chat_contacts(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-) -> *mut dc_array_t {
+pub unsafe fn dc_get_chat_contacts(context: &dc_context_t, chat_id: uint32_t) -> *mut dc_array_t {
     /* Normal chats do not include SELF.  Group chats do (as it may happen that one is deleted from a
     groupchat but the chats stays visible, moreover, this makes displaying lists easier) */
-    let mut ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
+    let ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
 
     if !(chat_id == 1i32 as libc::c_uint) {
@@ -1611,9 +1589,9 @@ pub unsafe fn dc_get_chat_contacts(
     ret
 }
 
-pub unsafe fn dc_get_chat(mut context: &dc_context_t, mut chat_id: uint32_t) -> *mut dc_chat_t {
+pub unsafe fn dc_get_chat(context: &dc_context_t, chat_id: uint32_t) -> *mut dc_chat_t {
     let mut success: libc::c_int = 0i32;
-    let mut obj: *mut dc_chat_t = dc_chat_new(context);
+    let obj: *mut dc_chat_t = dc_chat_new(context);
 
     if !(0 == dc_chat_load_from_db(obj, chat_id)) {
         success = 1i32
@@ -1629,15 +1607,15 @@ pub unsafe fn dc_get_chat(mut context: &dc_context_t, mut chat_id: uint32_t) ->
 
 // handle group chats
 pub unsafe fn dc_create_group_chat(
-    mut context: &dc_context_t,
-    mut verified: libc::c_int,
-    mut chat_name: *const libc::c_char,
+    context: &dc_context_t,
+    verified: libc::c_int,
+    chat_name: *const libc::c_char,
 ) -> uint32_t {
     let mut chat_id: uint32_t = 0i32 as uint32_t;
-    let mut draft_txt: *mut libc::c_char;
+    let draft_txt: *mut libc::c_char;
     let mut draft_msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
-    let mut grpid: *mut libc::c_char;
-    let mut stmt: *mut sqlite3_stmt;
+    let grpid: *mut libc::c_char;
+    let stmt: *mut sqlite3_stmt;
     if chat_name.is_null() || *chat_name.offset(0isize) as libc::c_int == 0i32 {
         return 0i32 as uint32_t;
     }
@@ -1688,13 +1666,13 @@ pub unsafe fn dc_create_group_chat(
 // Context functions to work with chats
 // TODO should return bool /rtn
 pub unsafe fn dc_add_to_chat_contacts_table(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    contact_id: uint32_t,
 ) -> libc::c_int {
     /* add a contact to a chat; the function does not check the type or if any of the record exist or are already added to the chat! */
-    let mut ret: libc::c_int;
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let ret: libc::c_int;
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"INSERT INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)\x00" as *const u8
@@ -1712,24 +1690,24 @@ pub unsafe fn dc_add_to_chat_contacts_table(
 }
 
 pub unsafe fn dc_add_contact_to_chat(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    contact_id: uint32_t,
 ) -> libc::c_int {
     dc_add_contact_to_chat_ex(context, chat_id, contact_id, 0i32)
 }
 
 // TODO should return bool /rtn
 pub unsafe fn dc_add_contact_to_chat_ex(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut contact_id: uint32_t,
-    mut flags: libc::c_int,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    contact_id: uint32_t,
+    flags: libc::c_int,
 ) -> libc::c_int {
     let mut current_block: u64;
     let mut success: libc::c_int = 0i32;
-    let mut contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
-    let mut chat: *mut dc_chat_t = dc_chat_new(context);
+    let contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
+    let chat: *mut dc_chat_t = dc_chat_new(context);
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(contact.is_null() || chat_id <= 9i32 as libc::c_uint) {
@@ -1843,9 +1821,9 @@ pub unsafe fn dc_add_contact_to_chat_ex(
 }
 
 // TODO should return bool /rtn
-unsafe fn real_group_exists(mut context: &dc_context_t, mut chat_id: uint32_t) -> libc::c_int {
+unsafe fn real_group_exists(context: &dc_context_t, chat_id: uint32_t) -> libc::c_int {
     // check if a group or a verified group exists under the given ID
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     let mut ret: libc::c_int = 0i32;
     if (*context.sql.clone().read().unwrap()).cobj.is_null() || chat_id <= 9i32 as libc::c_uint {
         return 0i32;
@@ -1864,16 +1842,16 @@ unsafe fn real_group_exists(mut context: &dc_context_t, mut chat_id: uint32_t) -
     ret
 }
 
-pub unsafe fn dc_reset_gossiped_timestamp(mut context: &dc_context_t, mut chat_id: uint32_t) {
+pub unsafe fn dc_reset_gossiped_timestamp(context: &dc_context_t, chat_id: uint32_t) {
     dc_set_gossiped_timestamp(context, chat_id, 0i32 as time_t);
 }
 
 pub unsafe fn dc_set_gossiped_timestamp(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut timestamp: time_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    timestamp: time_t,
 ) {
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     if 0 != chat_id {
         dc_log_info(
             context,
@@ -1910,13 +1888,13 @@ pub unsafe fn dc_set_gossiped_timestamp(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_remove_contact_from_chat(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    contact_id: uint32_t,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
-    let mut contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
-    let mut chat: *mut dc_chat_t = dc_chat_new(context);
+    let contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
+    let chat: *mut dc_chat_t = dc_chat_new(context);
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(chat_id <= 9i32 as libc::c_uint
@@ -1995,12 +1973,9 @@ pub unsafe fn dc_remove_contact_from_chat(
     success
 }
 
-pub unsafe fn dc_set_group_explicitly_left(
-    mut context: &dc_context_t,
-    mut grpid: *const libc::c_char,
-) {
+pub unsafe fn dc_set_group_explicitly_left(context: &dc_context_t, grpid: *const libc::c_char) {
     if 0 == dc_is_group_explicitly_left(context, grpid) {
-        let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+        let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
             context,
             &context.sql.clone().read().unwrap(),
             b"INSERT INTO leftgrps (grpid) VALUES(?);\x00" as *const u8 as *const libc::c_char,
@@ -2013,29 +1988,29 @@ pub unsafe fn dc_set_group_explicitly_left(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_is_group_explicitly_left(
-    mut context: &dc_context_t,
-    mut grpid: *const libc::c_char,
+    context: &dc_context_t,
+    grpid: *const libc::c_char,
 ) -> libc::c_int {
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"SELECT id FROM leftgrps WHERE grpid=?;\x00" as *const u8 as *const libc::c_char,
     );
     sqlite3_bind_text(stmt, 1i32, grpid, -1i32, None);
-    let mut ret: libc::c_int = (sqlite3_step(stmt) == 100i32) as libc::c_int;
+    let ret: libc::c_int = (sqlite3_step(stmt) == 100i32) as libc::c_int;
     sqlite3_finalize(stmt);
     ret
 }
 
 // TODO should return bool /rtn
 pub unsafe fn dc_set_chat_name(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut new_name: *const libc::c_char,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    new_name: *const libc::c_char,
 ) -> libc::c_int {
     /* the function only sets the names of group chats; normal chats get their names from the contacts */
     let mut success: libc::c_int = 0i32;
-    let mut chat: *mut dc_chat_t = dc_chat_new(context);
+    let chat: *mut dc_chat_t = dc_chat_new(context);
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(new_name.is_null()
@@ -2104,13 +2079,13 @@ pub unsafe fn dc_set_chat_name(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_set_chat_profile_image(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut new_image: *const libc::c_char,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    new_image: *const libc::c_char,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut success: libc::c_int = 0i32;
-    let mut chat: *mut dc_chat_t = dc_chat_new(context);
+    let chat: *mut dc_chat_t = dc_chat_new(context);
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let mut new_image_rel: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(chat_id <= 9i32 as libc::c_uint) {
@@ -2187,20 +2162,20 @@ pub unsafe fn dc_set_chat_profile_image(
 }
 
 pub unsafe fn dc_forward_msgs(
-    mut context: &dc_context_t,
-    mut msg_ids: *const uint32_t,
-    mut msg_cnt: libc::c_int,
-    mut chat_id: uint32_t,
+    context: &dc_context_t,
+    msg_ids: *const uint32_t,
+    msg_cnt: libc::c_int,
+    chat_id: uint32_t,
 ) {
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
-    let mut chat: *mut dc_chat_t = dc_chat_new(context);
-    let mut contact: *mut dc_contact_t = dc_contact_new(context);
-    let mut created_db_entries: *mut carray = carray_new(16i32 as libc::c_uint);
+    let chat: *mut dc_chat_t = dc_chat_new(context);
+    let contact: *mut dc_contact_t = dc_contact_new(context);
+    let created_db_entries: *mut carray = carray_new(16i32 as libc::c_uint);
     let mut idsstr: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut curr_timestamp: time_t;
-    let mut original_param: *mut dc_param_t = dc_param_new();
+    let original_param: *mut dc_param_t = dc_param_new();
     if !(msg_ids.is_null() || msg_cnt <= 0i32 || chat_id <= 9i32 as libc::c_uint) {
         dc_unarchive_chat(context, chat_id);
         if !(0 == dc_chat_load_from_db(chat, chat_id)) {
@@ -2216,7 +2191,7 @@ pub unsafe fn dc_forward_msgs(
                 if !(sqlite3_step(stmt) == 100i32) {
                     break;
                 }
-                let mut src_msg_id: libc::c_int = sqlite3_column_int(stmt, 0i32);
+                let src_msg_id: libc::c_int = sqlite3_column_int(stmt, 0i32);
                 if 0 == dc_msg_load_from_db(msg, context, src_msg_id as uint32_t) {
                     break;
                 }
@@ -2227,20 +2202,20 @@ pub unsafe fn dc_forward_msgs(
                 dc_param_set((*msg).param, 'c' as i32, 0 as *const libc::c_char);
                 dc_param_set((*msg).param, 'u' as i32, 0 as *const libc::c_char);
                 dc_param_set((*msg).param, 'S' as i32, 0 as *const libc::c_char);
-                let mut new_msg_id: uint32_t;
+                let new_msg_id: uint32_t;
                 if (*msg).state == 18i32 {
                     let fresh9 = curr_timestamp;
                     curr_timestamp = curr_timestamp + 1;
                     new_msg_id = prepare_msg_raw(context, chat, msg, fresh9);
-                    let mut save_param: *mut dc_param_t = (*msg).param;
+                    let save_param: *mut dc_param_t = (*msg).param;
                     (*msg).param = original_param;
                     (*msg).id = src_msg_id as uint32_t;
-                    let mut old_fwd: *mut libc::c_char = dc_param_get(
+                    let old_fwd: *mut libc::c_char = dc_param_get(
                         (*msg).param,
                         'P' as i32,
                         b"\x00" as *const u8 as *const libc::c_char,
                     );
-                    let mut new_fwd: *mut libc::c_char = dc_mprintf(
+                    let new_fwd: *mut libc::c_char = dc_mprintf(
                         b"%s %d\x00" as *const u8 as *const libc::c_char,
                         old_fwd,
                         new_msg_id,
@@ -2272,7 +2247,7 @@ pub unsafe fn dc_forward_msgs(
     }
     if !created_db_entries.is_null() {
         let mut i = 0u32;
-        let mut icnt = carray_count(created_db_entries);
+        let icnt = carray_count(created_db_entries);
         while i < icnt {
             (context.cb)(
                 context,
@@ -2293,28 +2268,28 @@ pub unsafe fn dc_forward_msgs(
     dc_param_unref(original_param);
 }
 
-pub unsafe fn dc_chat_get_id(mut chat: *const dc_chat_t) -> uint32_t {
+pub unsafe fn dc_chat_get_id(chat: *const dc_chat_t) -> uint32_t {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return 0i32 as uint32_t;
     }
     (*chat).id
 }
 
-pub unsafe fn dc_chat_get_type(mut chat: *const dc_chat_t) -> libc::c_int {
+pub unsafe fn dc_chat_get_type(chat: *const dc_chat_t) -> libc::c_int {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return 0i32;
     }
     (*chat).type_0
 }
 
-pub unsafe fn dc_chat_get_name(mut chat: *const dc_chat_t) -> *mut libc::c_char {
+pub unsafe fn dc_chat_get_name(chat: *const dc_chat_t) -> *mut libc::c_char {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return dc_strdup(b"Err\x00" as *const u8 as *const libc::c_char);
     }
     dc_strdup((*chat).name)
 }
 
-pub unsafe extern "C" fn dc_chat_get_subtitle(mut chat: *const dc_chat_t) -> *mut libc::c_char {
+pub unsafe extern "C" fn dc_chat_get_subtitle(chat: *const dc_chat_t) -> *mut libc::c_char {
     /* returns either the address or the number of chat members */
     let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
@@ -2323,8 +2298,8 @@ pub unsafe extern "C" fn dc_chat_get_subtitle(mut chat: *const dc_chat_t) -> *mu
     if (*chat).type_0 == 100i32 && 0 != dc_param_exists((*chat).param, 'K' as i32) {
         ret = dc_stock_str((*chat).context, 50i32)
     } else if (*chat).type_0 == 100i32 {
-        let mut r: libc::c_int;
-        let mut stmt: *mut sqlite3_stmt =
+        let r: libc::c_int;
+        let  stmt: *mut sqlite3_stmt =
             dc_sqlite3_prepare(
                 (*chat).context,&mut (*chat).context.sql.clone().read().unwrap(),
                                b"SELECT c.addr FROM chats_contacts cc  LEFT JOIN contacts c ON c.id=cc.contact_id  WHERE cc.chat_id=?;\x00"
@@ -2336,7 +2311,7 @@ pub unsafe extern "C" fn dc_chat_get_subtitle(mut chat: *const dc_chat_t) -> *mu
         }
         sqlite3_finalize(stmt);
     } else if (*chat).type_0 == 120i32 || (*chat).type_0 == 130i32 {
-        let mut cnt: libc::c_int;
+        let cnt: libc::c_int;
         if (*chat).id == 1i32 as libc::c_uint {
             ret = dc_stock_str((*chat).context, 8i32)
         } else {
@@ -2351,12 +2326,9 @@ pub unsafe extern "C" fn dc_chat_get_subtitle(mut chat: *const dc_chat_t) -> *mu
     };
 }
 
-pub unsafe fn dc_get_chat_contact_cnt(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-) -> libc::c_int {
+pub unsafe fn dc_get_chat_contact_cnt(context: &dc_context_t, chat_id: uint32_t) -> libc::c_int {
     let mut ret: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;\x00" as *const u8
@@ -2370,7 +2342,7 @@ pub unsafe fn dc_get_chat_contact_cnt(
     ret
 }
 
-pub unsafe fn dc_chat_get_profile_image(mut chat: *const dc_chat_t) -> *mut libc::c_char {
+pub unsafe fn dc_chat_get_profile_image(chat: *const dc_chat_t) -> *mut libc::c_char {
     let mut image_rel: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut image_abs: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut contacts: *mut dc_array_t = 0 as *mut dc_array_t;
@@ -2398,7 +2370,7 @@ pub unsafe fn dc_chat_get_profile_image(mut chat: *const dc_chat_t) -> *mut libc
     image_abs
 }
 
-pub unsafe fn dc_chat_get_color(mut chat: *const dc_chat_t) -> uint32_t {
+pub unsafe fn dc_chat_get_color(chat: *const dc_chat_t) -> uint32_t {
     let mut color: uint32_t = 0i32 as uint32_t;
     let mut contacts: *mut dc_array_t = 0 as *mut dc_array_t;
     let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
@@ -2424,7 +2396,7 @@ pub unsafe fn dc_chat_get_color(mut chat: *const dc_chat_t) -> uint32_t {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_chat_get_archived(mut chat: *const dc_chat_t) -> libc::c_int {
+pub unsafe fn dc_chat_get_archived(chat: *const dc_chat_t) -> libc::c_int {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return 0i32;
     }
@@ -2432,7 +2404,7 @@ pub unsafe fn dc_chat_get_archived(mut chat: *const dc_chat_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_chat_is_unpromoted(mut chat: *const dc_chat_t) -> libc::c_int {
+pub unsafe fn dc_chat_is_unpromoted(chat: *const dc_chat_t) -> libc::c_int {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return 0i32;
     }
@@ -2440,7 +2412,7 @@ pub unsafe fn dc_chat_is_unpromoted(mut chat: *const dc_chat_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_chat_is_verified(mut chat: *const dc_chat_t) -> libc::c_int {
+pub unsafe fn dc_chat_is_verified(chat: *const dc_chat_t) -> libc::c_int {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return 0i32;
     }
@@ -2448,14 +2420,14 @@ pub unsafe fn dc_chat_is_verified(mut chat: *const dc_chat_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_chat_is_sending_locations(mut chat: *const dc_chat_t) -> libc::c_int {
+pub unsafe fn dc_chat_is_sending_locations(chat: *const dc_chat_t) -> libc::c_int {
     if chat.is_null() || (*chat).magic != 0xc4a7c4a7u32 {
         return 0i32;
     }
     (*chat).is_sending_locations
 }
 
-pub unsafe fn dc_get_chat_cnt(mut context: &dc_context_t) -> size_t {
+pub unsafe fn dc_get_chat_cnt(context: &dc_context_t) -> size_t {
     let mut ret: size_t = 0i32 as size_t;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !(*context.sql.clone().read().unwrap()).cobj.is_null() {
@@ -2475,13 +2447,13 @@ pub unsafe fn dc_get_chat_cnt(mut context: &dc_context_t) -> size_t {
 }
 
 pub unsafe fn dc_get_chat_id_by_grpid(
-    mut context: &dc_context_t,
-    mut grpid: *const libc::c_char,
-    mut ret_blocked: *mut libc::c_int,
-    mut ret_verified: *mut libc::c_int,
+    context: &dc_context_t,
+    grpid: *const libc::c_char,
+    ret_blocked: *mut libc::c_int,
+    ret_verified: *mut libc::c_int,
 ) -> uint32_t {
     let mut chat_id: uint32_t = 0i32 as uint32_t;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     if !ret_blocked.is_null() {
         *ret_blocked = 0i32
     }
@@ -2511,13 +2483,13 @@ pub unsafe fn dc_get_chat_id_by_grpid(
 }
 
 pub unsafe fn dc_add_device_msg(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut text: *const libc::c_char,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    text: *const libc::c_char,
 ) {
-    let mut msg_id: uint32_t;
+    let msg_id: uint32_t;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut rfc724_mid: *mut libc::c_char = dc_create_outgoing_rfc724_mid(
+    let rfc724_mid: *mut libc::c_char = dc_create_outgoing_rfc724_mid(
         0 as *const libc::c_char,
         b"@device\x00" as *const u8 as *const libc::c_char,
     );
diff --git a/src/dc_chatlist.rs b/src/dc_chatlist.rs
index bf3d7b10a..4f89e7ce3 100644
--- a/src/dc_chatlist.rs
+++ b/src/dc_chatlist.rs
@@ -22,13 +22,13 @@ pub struct dc_chatlist_t<'a> {
 
 // handle chatlists
 pub unsafe fn dc_get_chatlist<'a>(
-    mut context: &'a dc_context_t,
-    mut listflags: libc::c_int,
-    mut query_str: *const libc::c_char,
-    mut query_id: uint32_t,
+    context: &'a dc_context_t,
+    listflags: libc::c_int,
+    query_str: *const libc::c_char,
+    query_id: uint32_t,
 ) -> *mut dc_chatlist_t<'a> {
     let mut success: libc::c_int = 0i32;
-    let mut obj: *mut dc_chatlist_t = dc_chatlist_new(context);
+    let obj: *mut dc_chatlist_t = dc_chatlist_new(context);
 
     if !(0 == dc_chatlist_load_from_db(obj, listflags, query_str, query_id)) {
         success = 1i32
@@ -80,7 +80,7 @@ pub unsafe fn dc_get_chatlist<'a>(
  * Rendering the deaddrop in the described way
  * would not add extra work in the UI then.
  */
-pub unsafe fn dc_chatlist_new(mut context: &dc_context_t) -> *mut dc_chatlist_t {
+pub unsafe fn dc_chatlist_new(context: &dc_context_t) -> *mut dc_chatlist_t {
     let mut chatlist: *mut dc_chatlist_t;
     chatlist = calloc(1, ::std::mem::size_of::<dc_chatlist_t>()) as *mut dc_chatlist_t;
     if chatlist.is_null() {
@@ -121,11 +121,11 @@ pub unsafe fn dc_chatlist_empty(mut chatlist: *mut dc_chatlist_t) {
 // TODO should return bool /rtn
 unsafe fn dc_chatlist_load_from_db(
     mut chatlist: *mut dc_chatlist_t,
-    mut listflags: libc::c_int,
-    mut query__: *const libc::c_char,
-    mut query_contact_id: uint32_t,
+    listflags: libc::c_int,
+    query__: *const libc::c_char,
+    query_contact_id: uint32_t,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     //clock_t       start = clock();
     let mut success: libc::c_int = 0i32;
     let mut add_archived_link_item: libc::c_int = 0i32;
@@ -164,7 +164,7 @@ unsafe fn dc_chatlist_load_from_db(
             current_block = 3437258052017859086;
         } else if query__.is_null() {
             if 0 == listflags & 0x2i32 {
-                let mut last_deaddrop_fresh_msg_id: uint32_t =
+                let last_deaddrop_fresh_msg_id: uint32_t =
                     get_last_deaddrop_fresh_msg((*chatlist).context);
                 if last_deaddrop_fresh_msg_id > 0i32 as libc::c_uint {
                     dc_array_add_id((*chatlist).chatNlastmsg_ids, 1i32 as uint32_t);
@@ -233,9 +233,9 @@ unsafe fn dc_chatlist_load_from_db(
 }
 
 // Context functions to work with chatlist
-pub unsafe fn dc_get_archived_cnt(mut context: &dc_context_t) -> libc::c_int {
+pub unsafe fn dc_get_archived_cnt(context: &dc_context_t) -> libc::c_int {
     let mut ret: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;\x00" as *const u8
@@ -248,9 +248,9 @@ pub unsafe fn dc_get_archived_cnt(mut context: &dc_context_t) -> libc::c_int {
     ret
 }
 
-unsafe fn get_last_deaddrop_fresh_msg(mut context: &dc_context_t) -> uint32_t {
+unsafe fn get_last_deaddrop_fresh_msg(context: &dc_context_t) -> uint32_t {
     let mut ret: uint32_t = 0i32 as uint32_t;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     stmt =
         dc_sqlite3_prepare(
             context,
@@ -265,17 +265,14 @@ unsafe fn get_last_deaddrop_fresh_msg(mut context: &dc_context_t) -> uint32_t {
     ret
 }
 
-pub unsafe fn dc_chatlist_get_cnt(mut chatlist: *const dc_chatlist_t) -> size_t {
+pub unsafe fn dc_chatlist_get_cnt(chatlist: *const dc_chatlist_t) -> size_t {
     if chatlist.is_null() || (*chatlist).magic != 0xc4a71157u32 {
         return 0i32 as size_t;
     }
     (*chatlist).cnt
 }
 
-pub unsafe fn dc_chatlist_get_chat_id(
-    mut chatlist: *const dc_chatlist_t,
-    mut index: size_t,
-) -> uint32_t {
+pub unsafe fn dc_chatlist_get_chat_id(chatlist: *const dc_chatlist_t, index: size_t) -> uint32_t {
     if chatlist.is_null()
         || (*chatlist).magic != 0xc4a71157u32
         || (*chatlist).chatNlastmsg_ids.is_null()
@@ -286,10 +283,7 @@ pub unsafe fn dc_chatlist_get_chat_id(
     dc_array_get_id((*chatlist).chatNlastmsg_ids, index.wrapping_mul(2))
 }
 
-pub unsafe fn dc_chatlist_get_msg_id(
-    mut chatlist: *const dc_chatlist_t,
-    mut index: size_t,
-) -> uint32_t {
+pub unsafe fn dc_chatlist_get_msg_id(chatlist: *const dc_chatlist_t, index: size_t) -> uint32_t {
     if chatlist.is_null()
         || (*chatlist).magic != 0xc4a71157u32
         || (*chatlist).chatNlastmsg_ids.is_null()
@@ -304,11 +298,11 @@ pub unsafe fn dc_chatlist_get_msg_id(
 }
 
 pub unsafe fn dc_chatlist_get_summary<'a>(
-    mut chatlist: *const dc_chatlist_t<'a>,
-    mut index: size_t,
+    chatlist: *const dc_chatlist_t<'a>,
+    index: size_t,
     mut chat: *mut dc_chat_t<'a>,
 ) -> *mut dc_lot_t {
-    let mut current_block: u64;
+    let current_block: u64;
     /* The summary is created by the chat, not by the last message.
     This is because we may want to display drafts here or stuff as
     "is typing".
@@ -316,7 +310,7 @@ pub unsafe fn dc_chatlist_get_summary<'a>(
     message. */
     /* the function never returns NULL */
     let mut ret: *mut dc_lot_t = dc_lot_new();
-    let mut lastmsg_id: uint32_t;
+    let lastmsg_id: uint32_t;
     let mut lastmsg: *mut dc_msg_t = 0 as *mut dc_msg_t;
     let mut lastcontact: *mut dc_contact_t = 0 as *mut dc_contact_t;
     let mut chat_to_delete: *mut dc_chat_t = 0 as *mut dc_chat_t;
diff --git a/src/dc_configure.rs b/src/dc_configure.rs
index 53a34e995..1844e23c0 100644
--- a/src/dc_configure.rs
+++ b/src/dc_configure.rs
@@ -55,7 +55,7 @@ pub struct outlk_autodiscover_t {
     pub redirect: *mut libc::c_char,
 }
 // connect
-pub unsafe fn dc_configure(mut context: &dc_context_t) {
+pub unsafe fn dc_configure(context: &dc_context_t) {
     if 0 != dc_has_ongoing(context) {
         dc_log_warning(
             context,
@@ -68,7 +68,7 @@ pub unsafe fn dc_configure(mut context: &dc_context_t) {
     dc_job_kill_action(context, 900i32);
     dc_job_add(context, 900i32, 0i32, 0 as *const libc::c_char, 0i32);
 }
-pub unsafe fn dc_has_ongoing(mut context: &dc_context_t) -> libc::c_int {
+pub unsafe fn dc_has_ongoing(context: &dc_context_t) -> libc::c_int {
     let s_a = context.running_state.clone();
     let s = s_a.read().unwrap();
 
@@ -78,7 +78,7 @@ pub unsafe fn dc_has_ongoing(mut context: &dc_context_t) -> libc::c_int {
         0
     }
 }
-pub unsafe fn dc_is_configured(mut context: &dc_context_t) -> libc::c_int {
+pub unsafe fn dc_is_configured(context: &dc_context_t) -> libc::c_int {
     return if 0
         != dc_sqlite3_get_config_int(
             context,
@@ -112,13 +112,13 @@ pub unsafe fn dc_stop_ongoing_process(context: &dc_context_t) {
 }
 // the other dc_job_do_DC_JOB_*() functions are declared static in the c-file
 pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut dc_job_t) {
-    let mut flags: libc::c_int;
+    let flags: libc::c_int;
     let mut current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut imap_connected_here: libc::c_int = 0i32;
     let mut smtp_connected_here: libc::c_int = 0i32;
     let mut ongoing_allocated_here: libc::c_int = 0i32;
-    let mut mvbox_folder: *mut libc::c_char = 0 as *mut libc::c_char;
+    let mvbox_folder: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut param: *mut dc_loginparam_t = 0 as *mut dc_loginparam_t;
     /* just a pointer inside param, must not be freed! */
     let mut param_domain: *mut libc::c_char;
@@ -205,7 +205,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                 }) as uintptr_t,
                                 0i32 as uintptr_t,
                             );
-                            let mut oauth2_addr: *mut libc::c_char =
+                            let oauth2_addr: *mut libc::c_char =
                                 dc_get_oauth2_addr(context, (*param).addr, (*param).mail_pw);
                             if !oauth2_addr.is_null() {
                                 free((*param).addr as *mut libc::c_void);
@@ -281,11 +281,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                         /*&&param->mail_user   ==NULL -- the user can enter a loginname which is used by autoconfig then */
                                         /*&&param->send_pw     ==NULL -- the password cannot be auto-configured and is no criterion for autoconfig or not */
                                         /* flags but OAuth2 avoid autoconfig */
-                                        let mut keep_flags: libc::c_int =
+                                        let keep_flags: libc::c_int =
                                             (*param).server_flags & 0x2i32;
                                         /* A.  Search configurations from the domain used in the email-address, prefer encrypted */
                                         if param_autoconfig.is_null() {
-                                            let mut url:
+                                            let  url:
                                             *mut libc::c_char =
                                                 dc_mprintf(b"https://autoconfig.%s/mail/config-v1.1.xml?emailaddress=%s\x00"
                                                            as
@@ -323,7 +323,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                             _ => {
                                                 if param_autoconfig.is_null() {
                                                     // the doc does not mention `emailaddress=`, however, Thunderbird adds it, see https://releases.mozilla.org/pub/thunderbird/ ,  which makes some sense
-                                                    let mut url_0:
+                                                    let  url_0:
                                                     *mut libc::c_char =
                                                         dc_mprintf(b"https://%s/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress=%s\x00"
                                                                    as
@@ -368,7 +368,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                             }
                                                             if param_autoconfig.is_null() {
                                                                 /* Outlook uses always SSL but different domains */
-                                                                let mut url_1:
+                                                                let  url_1:
                                                                 *mut libc::c_char =
                                                                     dc_mprintf(b"https://%s%s/autodiscover/autodiscover.xml\x00"
                                                                                as
@@ -424,7 +424,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                             2927484062889439186 => {}
                                                             _ => {
                                                                 if param_autoconfig.is_null() {
-                                                                    let mut url_2:
+                                                                    let  url_2:
                                                                     *mut libc::c_char =
                                                                         dc_mprintf(b"http://autoconfig.%s/mail/config-v1.1.xml?emailaddress=%s\x00"
                                                                                    as
@@ -481,7 +481,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                                             .is_null()
                                                                         {
                                                                             // do not transfer the email-address unencrypted
-                                                                            let mut url_3:
+                                                                            let  url_3:
                                                                             *mut libc::c_char =
                                                                                 dc_mprintf(b"http://%s/.well-known/autoconfig/mail/config-v1.1.xml\x00"
                                                                                            as
@@ -540,7 +540,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                                                     .is_null()
                                                                                 {
                                                                                     /* always SSL for Thunderbird's database */
-                                                                                    let mut url_4:
+                                                                                    let  url_4:
                                                                                     *mut libc::c_char =
                                                                                         dc_mprintf(b"https://autoconfig.thunderbird.net/v1.1/%s\x00"
                                                                                                    as
@@ -602,7 +602,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                                                     {
                                                                                         if !param_autoconfig.is_null()
                                                                                         {
-                                                                                            let mut r:
+                                                                                            let  r:
                                                                                             *mut libc::c_char =
                                                                                                 dc_loginparam_get_readable(param_autoconfig);
                                                                                             dc_log_info(context,
@@ -803,7 +803,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                         current_block = 14187386403465544025;
                                                         break;
                                                     }
-                                                    let mut r_0: *mut libc::c_char =
+                                                    let r_0: *mut libc::c_char =
                                                         dc_loginparam_get_readable(param);
                                                     dc_log_info(
                                                         context,
@@ -852,7 +852,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                     (*param).server_flags &=
                                                         !(0x100i32 | 0x200i32 | 0x400i32);
                                                     (*param).server_flags |= 0x100i32;
-                                                    let mut r_1: *mut libc::c_char =
+                                                    let r_1: *mut libc::c_char =
                                                         dc_loginparam_get_readable(param);
                                                     dc_log_info(
                                                         context,
@@ -895,7 +895,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                         0i32 as uintptr_t,
                                                     );
                                                     (*param).mail_port = 143i32;
-                                                    let mut r_2: *mut libc::c_char =
+                                                    let r_2: *mut libc::c_char =
                                                         dc_loginparam_get_readable(param);
                                                     dc_log_info(
                                                         context,
@@ -1009,7 +1009,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                                     (*param).server_flags |=
                                                                         0x10000i32;
                                                                     (*param).send_port = 587i32;
-                                                                    let mut r_3: *mut libc::c_char =
+                                                                    let r_3: *mut libc::c_char =
                                                                         dc_loginparam_get_readable(
                                                                             param,
                                                                         );
@@ -1063,7 +1063,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
                                                                                 0x10000i32;
                                                                             (*param).send_port =
                                                                                 25i32;
-                                                                            let mut r_4:
+                                                                            let  r_4:
                                                                             *mut libc::c_char =
                                                                                 dc_loginparam_get_readable(param);
                                                                             dc_log_info(context,
@@ -1301,13 +1301,13 @@ pub unsafe fn dc_free_ongoing(context: &dc_context_t) {
 }
 
 unsafe fn moz_autoconfigure(
-    mut context: &dc_context_t,
-    mut url: *const libc::c_char,
-    mut param_in: *const dc_loginparam_t,
+    context: &dc_context_t,
+    url: *const libc::c_char,
+    param_in: *const dc_loginparam_t,
 ) -> *mut dc_loginparam_t {
-    let mut p: *mut libc::c_char;
+    let p: *mut libc::c_char;
     let mut saxparser: dc_saxparser_t;
-    let mut xml_raw: *mut libc::c_char;
+    let xml_raw: *mut libc::c_char;
     let mut moz_ac: moz_autoconfigure_t = moz_autoconfigure_t {
         in_0: 0 as *const dc_loginparam_t,
         in_emaildomain: 0 as *mut libc::c_char,
@@ -1354,7 +1354,7 @@ unsafe fn moz_autoconfigure(
                 || (*moz_ac.out).send_server.is_null()
                 || (*moz_ac.out).send_port == 0i32
             {
-                let mut r: *mut libc::c_char = dc_loginparam_get_readable(moz_ac.out);
+                let r: *mut libc::c_char = dc_loginparam_get_readable(moz_ac.out);
                 dc_log_warning(
                     context,
                     0i32,
@@ -1451,10 +1451,7 @@ unsafe fn moz_autoconfigure_text_cb(
     }
     free(val as *mut libc::c_void);
 }
-unsafe fn moz_autoconfigure_endtag_cb(
-    mut userdata: *mut libc::c_void,
-    mut tag: *const libc::c_char,
-) {
+unsafe fn moz_autoconfigure_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char) {
     let mut moz_ac: *mut moz_autoconfigure_t = userdata as *mut moz_autoconfigure_t;
     if strcmp(
         tag,
@@ -1477,9 +1474,9 @@ unsafe fn moz_autoconfigure_endtag_cb(
     };
 }
 unsafe fn moz_autoconfigure_starttag_cb(
-    mut userdata: *mut libc::c_void,
-    mut tag: *const libc::c_char,
-    mut attr: *mut *mut libc::c_char,
+    userdata: *mut libc::c_void,
+    tag: *const libc::c_char,
+    attr: *mut *mut libc::c_char,
 ) {
     let mut moz_ac: *mut moz_autoconfigure_t = userdata as *mut moz_autoconfigure_t;
     let mut p1: *const libc::c_char = 0 as *const libc::c_char;
@@ -1522,10 +1519,10 @@ unsafe fn moz_autoconfigure_starttag_cb(
     };
 }
 unsafe fn read_autoconf_file(
-    mut context: &dc_context_t,
-    mut url: *const libc::c_char,
+    context: &dc_context_t,
+    url: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut filecontent: *mut libc::c_char;
+    let filecontent: *mut libc::c_char;
     dc_log_info(
         context,
         0i32,
@@ -1554,7 +1551,7 @@ unsafe fn outlk_autodiscover(
     url__: *const libc::c_char,
     param_in: *const dc_loginparam_t,
 ) -> *mut dc_loginparam_t {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut xml_raw: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut url: *mut libc::c_char = dc_strdup(url__);
     let mut outlk_ad: outlk_autodiscover_t = outlk_autodiscover_t {
@@ -1622,7 +1619,7 @@ unsafe fn outlk_autodiscover(
                 || (*outlk_ad.out).send_server.is_null()
                 || (*outlk_ad.out).send_port == 0i32
             {
-                let mut r: *mut libc::c_char = dc_loginparam_get_readable(outlk_ad.out);
+                let r: *mut libc::c_char = dc_loginparam_get_readable(outlk_ad.out);
                 dc_log_warning(
                     context,
                     0i32,
@@ -1655,25 +1652,22 @@ unsafe fn outlk_autodiscover_text_cb(
     _len: libc::c_int,
 ) {
     let mut outlk_ad: *mut outlk_autodiscover_t = userdata as *mut outlk_autodiscover_t;
-    let mut val: *mut libc::c_char = dc_strdup(text);
+    let val: *mut libc::c_char = dc_strdup(text);
     dc_trim(val);
     free((*outlk_ad).config[(*outlk_ad).tag_config as usize] as *mut libc::c_void);
     (*outlk_ad).config[(*outlk_ad).tag_config as usize] = val;
 }
-unsafe fn outlk_autodiscover_endtag_cb(
-    mut userdata: *mut libc::c_void,
-    mut tag: *const libc::c_char,
-) {
+unsafe fn outlk_autodiscover_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char) {
     let mut outlk_ad: *mut outlk_autodiscover_t = userdata as *mut outlk_autodiscover_t;
     if strcmp(tag, b"protocol\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if !(*outlk_ad).config[1usize].is_null() {
-            let mut port: libc::c_int = dc_atoi_null_is_0((*outlk_ad).config[3usize]);
-            let mut ssl_on: libc::c_int = (!(*outlk_ad).config[4usize].is_null()
+            let port: libc::c_int = dc_atoi_null_is_0((*outlk_ad).config[3usize]);
+            let ssl_on: libc::c_int = (!(*outlk_ad).config[4usize].is_null()
                 && strcasecmp(
                     (*outlk_ad).config[4usize],
                     b"on\x00" as *const u8 as *const libc::c_char,
                 ) == 0i32) as libc::c_int;
-            let mut ssl_off: libc::c_int = (!(*outlk_ad).config[4usize].is_null()
+            let ssl_off: libc::c_int = (!(*outlk_ad).config[4usize].is_null()
                 && strcasecmp(
                     (*outlk_ad).config[4usize],
                     b"off\x00" as *const u8 as *const libc::c_char,
@@ -1753,7 +1747,7 @@ pub unsafe fn dc_alloc_ongoing(context: &dc_context_t) -> libc::c_int {
 
 pub unsafe fn dc_connect_to_configured_imap(context: &dc_context_t, imap: &Imap) -> libc::c_int {
     let mut ret_connected: libc::c_int = 0i32;
-    let mut param: *mut dc_loginparam_t = dc_loginparam_new();
+    let param: *mut dc_loginparam_t = dc_loginparam_new();
     if imap.is_connected() {
         ret_connected = 1i32
     } else if dc_sqlite3_get_config_int(
diff --git a/src/dc_contact.rs b/src/dc_contact.rs
index 6e35c22e3..536546444 100644
--- a/src/dc_contact.rs
+++ b/src/dc_contact.rs
@@ -28,7 +28,7 @@ pub struct dc_contact_t<'a> {
 }
 
 pub unsafe fn dc_marknoticed_contact(context: &dc_context_t, contact_id: uint32_t) {
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE msgs SET state=13 WHERE from_id=? AND state=10;\x00" as *const u8
@@ -47,15 +47,15 @@ pub unsafe fn dc_marknoticed_contact(context: &dc_context_t, contact_id: uint32_
 
 // handle contacts
 // TODO should return bool /rtn
-pub unsafe extern "C" fn dc_may_be_valid_addr(mut addr: *const libc::c_char) -> libc::c_int {
+pub unsafe extern "C" fn dc_may_be_valid_addr(addr: *const libc::c_char) -> libc::c_int {
     if addr.is_null() {
         return 0i32;
     }
-    let mut at: *const libc::c_char = strchr(addr, '@' as i32);
+    let at: *const libc::c_char = strchr(addr, '@' as i32);
     if at.is_null() || (at.wrapping_offset_from(addr) as libc::c_long) < 1i32 as libc::c_long {
         return 0i32;
     }
-    let mut dot: *const libc::c_char = strchr(at, '.' as i32);
+    let dot: *const libc::c_char = strchr(at, '.' as i32);
     if dot.is_null()
         || (dot.wrapping_offset_from(at) as libc::c_long) < 2i32 as libc::c_long
         || *dot.offset(1isize) as libc::c_int == 0i32
@@ -68,8 +68,8 @@ pub unsafe extern "C" fn dc_may_be_valid_addr(mut addr: *const libc::c_char) ->
 }
 
 pub unsafe fn dc_lookup_contact_id_by_addr(
-    mut context: &dc_context_t,
-    mut addr: *const libc::c_char,
+    context: &dc_context_t,
+    addr: *const libc::c_char,
 ) -> uint32_t {
     let mut contact_id: libc::c_int = 0i32;
     let mut addr_normalized: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -112,7 +112,7 @@ pub unsafe fn dc_lookup_contact_id_by_addr(
     contact_id as uint32_t
 }
 
-pub unsafe fn dc_addr_normalize(mut addr: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_addr_normalize(addr: *const libc::c_char) -> *mut libc::c_char {
     let mut addr_normalized: *mut libc::c_char = dc_strdup(addr);
     dc_trim(addr_normalized);
     if strncmp(
@@ -121,7 +121,7 @@ pub unsafe fn dc_addr_normalize(mut addr: *const libc::c_char) -> *mut libc::c_c
         7,
     ) == 0i32
     {
-        let mut old: *mut libc::c_char = addr_normalized;
+        let old: *mut libc::c_char = addr_normalized;
         addr_normalized = dc_strdup(&mut *old.offset(7isize));
         free(old as *mut libc::c_void);
         dc_trim(addr_normalized);
@@ -131,13 +131,13 @@ pub unsafe fn dc_addr_normalize(mut addr: *const libc::c_char) -> *mut libc::c_c
 }
 
 pub unsafe fn dc_create_contact(
-    mut context: &dc_context_t,
-    mut name: *const libc::c_char,
-    mut addr: *const libc::c_char,
+    context: &dc_context_t,
+    name: *const libc::c_char,
+    addr: *const libc::c_char,
 ) -> uint32_t {
     let mut contact_id: uint32_t = 0i32 as uint32_t;
     let mut sth_modified: libc::c_int = 0i32;
-    let mut blocked: libc::c_int;
+    let blocked: libc::c_int;
     if !(addr.is_null() || *addr.offset(0isize) as libc::c_int == 0i32) {
         contact_id = dc_add_or_lookup_contact(context, name, addr, 0x4000000i32, &mut sth_modified);
         blocked = dc_is_contact_blocked(context, contact_id);
@@ -160,13 +160,13 @@ pub unsafe fn dc_create_contact(
 }
 
 pub unsafe fn dc_block_contact(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-    mut new_blocking: libc::c_int,
+    context: &dc_context_t,
+    contact_id: uint32_t,
+    new_blocking: libc::c_int,
 ) {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut send_event: libc::c_int = 0i32;
-    let mut contact: *mut dc_contact_t = dc_contact_new(context);
+    let contact: *mut dc_contact_t = dc_contact_new(context);
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !(contact_id <= 9i32 as libc::c_uint) {
         if 0 != dc_contact_load_from_db(contact, &context.sql.clone().read().unwrap(), contact_id)
@@ -302,7 +302,7 @@ pub unsafe fn dc_contact_load_from_db(
     sql: &dc_sqlite3_t,
     contact_id: uint32_t,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !(contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint) {
@@ -348,12 +348,9 @@ pub unsafe fn dc_contact_load_from_db(
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_is_contact_blocked(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-) -> libc::c_int {
+pub unsafe fn dc_is_contact_blocked(context: &dc_context_t, contact_id: uint32_t) -> libc::c_int {
     let mut is_blocked: libc::c_int = 0i32;
-    let mut contact: *mut dc_contact_t = dc_contact_new(context);
+    let contact: *mut dc_contact_t = dc_contact_new(context);
     if 0 != dc_contact_load_from_db(contact, &context.sql.clone().read().unwrap(), contact_id) {
         if 0 != (*contact).blocked {
             is_blocked = 1i32
@@ -366,10 +363,10 @@ pub unsafe fn dc_is_contact_blocked(
 
 /*can be NULL*/
 pub unsafe fn dc_add_or_lookup_contact(
-    mut context: &dc_context_t,
-    mut name: *const libc::c_char,
-    mut addr__: *const libc::c_char,
-    mut origin: libc::c_int,
+    context: &dc_context_t,
+    name: *const libc::c_char,
+    addr__: *const libc::c_char,
+    origin: libc::c_int,
     mut sth_modified: *mut libc::c_int,
 ) -> uint32_t {
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -414,7 +411,7 @@ pub unsafe fn dc_add_or_lookup_contact(
                                        as *const u8 as *const libc::c_char);
             sqlite3_bind_text(stmt, 1i32, addr as *const libc::c_char, -1i32, None);
             if sqlite3_step(stmt) == 100i32 {
-                let mut row_origin: libc::c_int;
+                let row_origin: libc::c_int;
                 let mut update_addr: libc::c_int = 0i32;
                 let mut update_name: libc::c_int = 0i32;
                 let mut update_authname: libc::c_int = 0i32;
@@ -554,12 +551,12 @@ pub unsafe fn dc_add_or_lookup_contact(
 }
 
 pub unsafe fn dc_add_address_book(
-    mut context: &dc_context_t,
-    mut adr_book: *const libc::c_char,
+    context: &dc_context_t,
+    adr_book: *const libc::c_char,
 ) -> libc::c_int {
     let mut lines: *mut carray = 0 as *mut carray;
     let mut i: size_t;
-    let mut iCnt: size_t;
+    let iCnt: size_t;
     let mut sth_modified: libc::c_int = 0i32;
     let mut modify_cnt: libc::c_int = 0i32;
     if !(adr_book.is_null()) {
@@ -568,9 +565,9 @@ pub unsafe fn dc_add_address_book(
             iCnt = carray_count(lines) as size_t;
             i = 0i32 as size_t;
             while i.wrapping_add(1) < iCnt {
-                let mut name: *mut libc::c_char =
+                let name: *mut libc::c_char =
                     carray_get(lines, i as libc::c_uint) as *mut libc::c_char;
-                let mut addr: *mut libc::c_char =
+                let addr: *mut libc::c_char =
                     carray_get(lines, i.wrapping_add(1) as libc::c_uint) as *mut libc::c_char;
                 dc_normalize_name(name);
                 dc_add_or_lookup_contact(context, name, addr, 0x80000i32, &mut sth_modified);
@@ -595,15 +592,15 @@ pub unsafe fn dc_add_address_book(
 }
 
 // Working with names
-pub unsafe fn dc_normalize_name(mut full_name: *mut libc::c_char) {
+pub unsafe fn dc_normalize_name(full_name: *mut libc::c_char) {
     if full_name.is_null() {
         return;
     }
     dc_trim(full_name);
-    let mut len: libc::c_int = strlen(full_name) as libc::c_int;
+    let len: libc::c_int = strlen(full_name) as libc::c_int;
     if len > 0i32 {
-        let mut firstchar: libc::c_char = *full_name.offset(0isize);
-        let mut lastchar: libc::c_char = *full_name.offset((len - 1i32) as isize);
+        let firstchar: libc::c_char = *full_name.offset(0isize);
+        let lastchar: libc::c_char = *full_name.offset((len - 1i32) as isize);
         if firstchar as libc::c_int == '\'' as i32 && lastchar as libc::c_int == '\'' as i32
             || firstchar as libc::c_int == '\"' as i32 && lastchar as libc::c_int == '\"' as i32
             || firstchar as libc::c_int == '<' as i32 && lastchar as libc::c_int == '>' as i32
@@ -612,11 +609,11 @@ pub unsafe fn dc_normalize_name(mut full_name: *mut libc::c_char) {
             *full_name.offset((len - 1i32) as isize) = ' ' as i32 as libc::c_char
         }
     }
-    let mut p1: *mut libc::c_char = strchr(full_name, ',' as i32);
+    let p1: *mut libc::c_char = strchr(full_name, ',' as i32);
     if !p1.is_null() {
         *p1 = 0i32 as libc::c_char;
-        let mut last_name: *mut libc::c_char = dc_strdup(full_name);
-        let mut first_name: *mut libc::c_char = dc_strdup(p1.offset(1isize));
+        let last_name: *mut libc::c_char = dc_strdup(full_name);
+        let first_name: *mut libc::c_char = dc_strdup(p1.offset(1isize));
         dc_trim(last_name);
         dc_trim(first_name);
         strcpy(full_name, first_name);
@@ -630,16 +627,16 @@ pub unsafe fn dc_normalize_name(mut full_name: *mut libc::c_char) {
 }
 
 pub unsafe fn dc_get_contacts(
-    mut context: &dc_context_t,
-    mut listflags: uint32_t,
-    mut query: *const libc::c_char,
+    context: &dc_context_t,
+    listflags: uint32_t,
+    query: *const libc::c_char,
 ) -> *mut dc_array_t {
-    let mut current_block: u64;
-    let mut self_addr: *mut libc::c_char;
+    let current_block: u64;
+    let self_addr: *mut libc::c_char;
     let mut self_name: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut self_name2: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut add_self: libc::c_int = 0i32;
-    let mut ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
+    let ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
     let mut s3strLikeCmd: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
 
@@ -732,7 +729,7 @@ pub unsafe fn dc_get_contacts(
 
 pub unsafe fn dc_get_blocked_cnt(context: &dc_context_t) -> libc::c_int {
     let mut ret: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
 
     stmt = dc_sqlite3_prepare(
         context,
@@ -749,9 +746,9 @@ pub unsafe fn dc_get_blocked_cnt(context: &dc_context_t) -> libc::c_int {
     ret
 }
 
-pub unsafe fn dc_get_blocked_contacts(mut context: &dc_context_t) -> *mut dc_array_t {
-    let mut ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
-    let mut stmt: *mut sqlite3_stmt;
+pub unsafe fn dc_get_blocked_contacts(context: &dc_context_t) -> *mut dc_array_t {
+    let ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
+    let stmt: *mut sqlite3_stmt;
 
     stmt = dc_sqlite3_prepare(
         context,
@@ -769,14 +766,14 @@ pub unsafe fn dc_get_blocked_contacts(mut context: &dc_context_t) -> *mut dc_arr
 }
 
 pub unsafe fn dc_get_contact_encrinfo(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    contact_id: uint32_t,
 ) -> *mut libc::c_char {
     let mut ret: dc_strbuilder_t;
-    let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new();
-    let mut contact: *mut dc_contact_t = dc_contact_new(context);
-    let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
-    let mut self_key: *mut dc_key_t = dc_key_new();
+    let loginparam: *mut dc_loginparam_t = dc_loginparam_new();
+    let contact: *mut dc_contact_t = dc_contact_new(context);
+    let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+    let self_key: *mut dc_key_t = dc_key_new();
     let mut fingerprint_self: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut fingerprint_other_verified: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut fingerprint_other_unverified: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -889,10 +886,10 @@ pub unsafe fn dc_get_contact_encrinfo(
 }
 
 unsafe fn cat_fingerprint(
-    mut ret: *mut dc_strbuilder_t,
-    mut addr: *const libc::c_char,
-    mut fingerprint_verified: *const libc::c_char,
-    mut fingerprint_unverified: *const libc::c_char,
+    ret: *mut dc_strbuilder_t,
+    addr: *const libc::c_char,
+    fingerprint_verified: *const libc::c_char,
+    fingerprint_unverified: *const libc::c_char,
 ) {
     dc_strbuilder_cat(ret, b"\n\n\x00" as *const u8 as *const libc::c_char);
     dc_strbuilder_cat(ret, addr);
@@ -924,10 +921,7 @@ unsafe fn cat_fingerprint(
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_delete_contact(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-) -> libc::c_int {
+pub unsafe fn dc_delete_contact(context: &dc_context_t, contact_id: uint32_t) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !contact_id <= 9i32 as libc::c_uint {
@@ -973,10 +967,7 @@ pub unsafe fn dc_delete_contact(
     success
 }
 
-pub unsafe fn dc_get_contact(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-) -> *mut dc_contact_t {
+pub unsafe fn dc_get_contact(context: &dc_context_t, contact_id: uint32_t) -> *mut dc_contact_t {
     let mut ret: *mut dc_contact_t = dc_contact_new(context);
     if 0 == dc_contact_load_from_db(ret, &context.sql.clone().read().unwrap(), contact_id) {
         dc_contact_unref(ret);
@@ -985,28 +976,28 @@ pub unsafe fn dc_get_contact(
     ret
 }
 
-pub unsafe fn dc_contact_get_id(mut contact: *const dc_contact_t) -> uint32_t {
+pub unsafe fn dc_contact_get_id(contact: *const dc_contact_t) -> uint32_t {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return 0i32 as uint32_t;
     }
     (*contact).id
 }
 
-pub unsafe fn dc_contact_get_addr(mut contact: *const dc_contact_t) -> *mut libc::c_char {
+pub unsafe fn dc_contact_get_addr(contact: *const dc_contact_t) -> *mut libc::c_char {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return dc_strdup(0 as *const libc::c_char);
     }
     dc_strdup((*contact).addr)
 }
 
-pub unsafe fn dc_contact_get_name(mut contact: *const dc_contact_t) -> *mut libc::c_char {
+pub unsafe fn dc_contact_get_name(contact: *const dc_contact_t) -> *mut libc::c_char {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return dc_strdup(0 as *const libc::c_char);
     }
     dc_strdup((*contact).name)
 }
 
-pub unsafe fn dc_contact_get_display_name(mut contact: *const dc_contact_t) -> *mut libc::c_char {
+pub unsafe fn dc_contact_get_display_name(contact: *const dc_contact_t) -> *mut libc::c_char {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return dc_strdup(0 as *const libc::c_char);
     }
@@ -1016,7 +1007,7 @@ pub unsafe fn dc_contact_get_display_name(mut contact: *const dc_contact_t) -> *
     dc_strdup((*contact).addr)
 }
 
-pub unsafe fn dc_contact_get_name_n_addr(mut contact: *const dc_contact_t) -> *mut libc::c_char {
+pub unsafe fn dc_contact_get_name_n_addr(contact: *const dc_contact_t) -> *mut libc::c_char {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return dc_strdup(0 as *const libc::c_char);
     }
@@ -1030,7 +1021,7 @@ pub unsafe fn dc_contact_get_name_n_addr(mut contact: *const dc_contact_t) -> *m
     dc_strdup((*contact).addr)
 }
 
-pub unsafe fn dc_contact_get_first_name(mut contact: *const dc_contact_t) -> *mut libc::c_char {
+pub unsafe fn dc_contact_get_first_name(contact: *const dc_contact_t) -> *mut libc::c_char {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return dc_strdup(0 as *const libc::c_char);
     }
@@ -1040,9 +1031,9 @@ pub unsafe fn dc_contact_get_first_name(mut contact: *const dc_contact_t) -> *mu
     dc_strdup((*contact).addr)
 }
 
-pub unsafe fn dc_get_first_name(mut full_name: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_get_first_name(full_name: *const libc::c_char) -> *mut libc::c_char {
     let mut first_name: *mut libc::c_char = dc_strdup(full_name);
-    let mut p1: *mut libc::c_char = strchr(first_name, ' ' as i32);
+    let p1: *mut libc::c_char = strchr(first_name, ' ' as i32);
     if !p1.is_null() {
         *p1 = 0i32 as libc::c_char;
         dc_rtrim(first_name);
@@ -1054,7 +1045,7 @@ pub unsafe fn dc_get_first_name(mut full_name: *const libc::c_char) -> *mut libc
     first_name
 }
 
-pub unsafe fn dc_contact_get_profile_image(mut contact: *const dc_contact_t) -> *mut libc::c_char {
+pub unsafe fn dc_contact_get_profile_image(contact: *const dc_contact_t) -> *mut libc::c_char {
     let mut selfavatar: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut image_abs: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint) {
@@ -1073,21 +1064,21 @@ pub unsafe fn dc_contact_get_profile_image(mut contact: *const dc_contact_t) ->
     image_abs
 }
 
-pub unsafe fn dc_contact_get_color(mut contact: *const dc_contact_t) -> uint32_t {
+pub unsafe fn dc_contact_get_color(contact: *const dc_contact_t) -> uint32_t {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return 0i32 as uint32_t;
     }
     dc_str_to_color((*contact).addr) as uint32_t
 }
 
-pub unsafe fn dc_contact_is_blocked(mut contact: *const dc_contact_t) -> libc::c_int {
+pub unsafe fn dc_contact_is_blocked(contact: *const dc_contact_t) -> libc::c_int {
     if contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint {
         return 0i32;
     }
     (*contact).blocked
 }
 
-pub unsafe fn dc_contact_is_verified(mut contact: *mut dc_contact_t) -> libc::c_int {
+pub unsafe fn dc_contact_is_verified(contact: *mut dc_contact_t) -> libc::c_int {
     dc_contact_is_verified_ex(contact, 0 as *mut dc_apeerstate_t)
 }
 
@@ -1095,7 +1086,7 @@ pub unsafe fn dc_contact_is_verified_ex<'a>(
     contact: *mut dc_contact_t<'a>,
     mut peerstate: *mut dc_apeerstate_t<'a>,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut contact_verified: libc::c_int = 0i32;
     let mut peerstate_to_delete: *mut dc_apeerstate_t = 0 as *mut dc_apeerstate_t;
     if !(contact.is_null() || (*contact).magic != 0xc047ac7i32 as libc::c_uint) {
@@ -1135,21 +1126,18 @@ pub unsafe fn dc_contact_is_verified_ex<'a>(
 }
 
 // Working with e-mail-addresses
-pub unsafe fn dc_addr_cmp(
-    mut addr1: *const libc::c_char,
-    mut addr2: *const libc::c_char,
-) -> libc::c_int {
-    let mut norm1: *mut libc::c_char = dc_addr_normalize(addr1);
-    let mut norm2: *mut libc::c_char = dc_addr_normalize(addr2);
-    let mut ret: libc::c_int = strcasecmp(addr1, addr2);
+pub unsafe fn dc_addr_cmp(addr1: *const libc::c_char, addr2: *const libc::c_char) -> libc::c_int {
+    let norm1: *mut libc::c_char = dc_addr_normalize(addr1);
+    let norm2: *mut libc::c_char = dc_addr_normalize(addr2);
+    let ret: libc::c_int = strcasecmp(addr1, addr2);
     free(norm1 as *mut libc::c_void);
     free(norm2 as *mut libc::c_void);
     ret
 }
 
 pub unsafe fn dc_addr_equals_self(
-    mut context: &dc_context_t,
-    mut addr: *const libc::c_char,
+    context: &dc_context_t,
+    addr: *const libc::c_char,
 ) -> libc::c_int {
     let mut ret: libc::c_int = 0i32;
     let mut normalized_addr: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -1177,16 +1165,16 @@ pub unsafe fn dc_addr_equals_self(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_addr_equals_contact(
-    mut context: &dc_context_t,
-    mut addr: *const libc::c_char,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    addr: *const libc::c_char,
+    contact_id: uint32_t,
 ) -> libc::c_int {
     let mut addr_are_equal: libc::c_int = 0i32;
     if !addr.is_null() {
-        let mut contact: *mut dc_contact_t = dc_contact_new(context);
+        let contact: *mut dc_contact_t = dc_contact_new(context);
         if 0 != dc_contact_load_from_db(contact, &context.sql.clone().read().unwrap(), contact_id) {
             if !(*contact).addr.is_null() {
-                let mut normalized_addr: *mut libc::c_char = dc_addr_normalize(addr);
+                let normalized_addr: *mut libc::c_char = dc_addr_normalize(addr);
                 if strcasecmp((*contact).addr, normalized_addr) == 0i32 {
                     addr_are_equal = 1i32
                 }
@@ -1199,7 +1187,7 @@ pub unsafe fn dc_addr_equals_contact(
 }
 
 // Context functions to work with contacts
-pub unsafe fn dc_get_real_contact_cnt(mut context: &dc_context_t) -> size_t {
+pub unsafe fn dc_get_real_contact_cnt(context: &dc_context_t) -> size_t {
     let mut ret: size_t = 0i32 as size_t;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !context.sql.clone().read().unwrap().cobj.is_null() {
@@ -1218,8 +1206,8 @@ pub unsafe fn dc_get_real_contact_cnt(mut context: &dc_context_t) -> size_t {
 }
 
 pub unsafe fn dc_get_contact_origin(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
+    context: &dc_context_t,
+    contact_id: uint32_t,
     mut ret_blocked: *mut libc::c_int,
 ) -> libc::c_int {
     let mut ret: libc::c_int = 0i32;
@@ -1227,7 +1215,7 @@ pub unsafe fn dc_get_contact_origin(
     if ret_blocked.is_null() {
         ret_blocked = &mut dummy
     }
-    let mut contact: *mut dc_contact_t = dc_contact_new(context);
+    let contact: *mut dc_contact_t = dc_contact_new(context);
     *ret_blocked = 0i32;
     if !(0 == dc_contact_load_from_db(contact, &context.sql.clone().read().unwrap(), contact_id)) {
         /* we could optimize this by loading only the needed fields */
@@ -1242,10 +1230,7 @@ pub unsafe fn dc_get_contact_origin(
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_real_contact_exists(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-) -> libc::c_int {
+pub unsafe fn dc_real_contact_exists(context: &dc_context_t, contact_id: uint32_t) -> libc::c_int {
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut ret: libc::c_int = 0i32;
     if !(context.sql.clone().read().unwrap().cobj.is_null() || contact_id <= 9i32 as libc::c_uint) {
@@ -1264,11 +1249,11 @@ pub unsafe fn dc_real_contact_exists(
 }
 
 pub unsafe fn dc_scaleup_contact_origin(
-    mut context: &dc_context_t,
-    mut contact_id: uint32_t,
-    mut origin: libc::c_int,
+    context: &dc_context_t,
+    contact_id: uint32_t,
+    origin: libc::c_int,
 ) {
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE contacts SET origin=? WHERE id=? AND origin<?;\x00" as *const u8
diff --git a/src/dc_context.rs b/src/dc_context.rs
index cbb9fb0dd..c1a537762 100644
--- a/src/dc_context.rs
+++ b/src/dc_context.rs
@@ -204,7 +204,7 @@ unsafe fn cb_precheck_imf(
     server_uid: uint32_t,
 ) -> libc::c_int {
     let mut rfc724_mid_exists: libc::c_int = 0i32;
-    let mut msg_id: uint32_t;
+    let msg_id: uint32_t;
     let mut old_server_folder: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut old_server_uid: uint32_t = 0i32 as uint32_t;
     let mut mark_seen: libc::c_int = 0i32;
@@ -390,7 +390,7 @@ pub unsafe fn dc_set_config(
         ret = dc_sqlite3_set_config(context, &context.sql.clone().read().unwrap(), key, value);
         dc_interrupt_mvbox_idle(context);
     } else if strcmp(key, b"selfstatus\x00" as *const u8 as *const libc::c_char) == 0 {
-        let mut def = dc_stock_str(context, 13);
+        let def = dc_stock_str(context, 13);
         ret = dc_sqlite3_set_config(
             context,
             &context.sql.clone().read().unwrap(),
@@ -479,7 +479,7 @@ pub unsafe fn dc_get_config(context: &dc_context_t, key: *const libc::c_char) ->
     }
 
     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(
+        let rel_path: *mut libc::c_char = dc_sqlite3_get_config(
             context,
             &context.sql.clone().read().unwrap(),
             key,
@@ -611,33 +611,33 @@ unsafe fn get_config_keys_str() -> *mut libc::c_char {
 }
 
 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;
-    let mut temp;
-    let mut l_readable_str;
-    let mut l2_readable_str;
-    let mut fingerprint_str;
-    let mut l;
-    let mut l2;
-    let mut inbox_watch;
-    let mut sentbox_watch;
-    let mut mvbox_watch;
-    let mut mvbox_move;
-    let mut folders_configured;
-    let mut configured_sentbox_folder;
-    let mut configured_mvbox_folder;
-    let mut contacts;
-    let mut chats;
-    let mut real_msgs;
-    let mut deaddrop_msgs;
-    let mut is_configured;
-    let mut dbversion;
-    let mut mdns_enabled;
-    let mut e2ee_enabled;
-    let mut prv_key_cnt;
-    let mut pub_key_cnt;
-    let mut self_public = dc_key_new();
-    let mut rpgp_enabled = 1;
+    let unset = b"0\x00" as *const u8 as *const libc::c_char;
+    let displayname;
+    let temp;
+    let l_readable_str;
+    let l2_readable_str;
+    let fingerprint_str;
+    let l;
+    let l2;
+    let inbox_watch;
+    let sentbox_watch;
+    let mvbox_watch;
+    let mvbox_move;
+    let folders_configured;
+    let configured_sentbox_folder;
+    let configured_mvbox_folder;
+    let contacts;
+    let chats;
+    let real_msgs;
+    let deaddrop_msgs;
+    let is_configured;
+    let dbversion;
+    let mdns_enabled;
+    let e2ee_enabled;
+    let prv_key_cnt;
+    let pub_key_cnt;
+    let self_public = dc_key_new();
+    let rpgp_enabled = 1;
 
     let mut ret = dc_strbuilder_t {
         buf: 0 as *mut libc::c_char,
@@ -868,8 +868,8 @@ pub unsafe fn dc_get_version_str() -> *mut libc::c_char {
 }
 
 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(128 as size_t);
+    let show_deaddrop = 0;
+    let ret = dc_array_new(128 as size_t);
     let mut stmt = 0 as *mut sqlite3_stmt;
     if !ret.is_null() {
         stmt = dc_sqlite3_prepare(
@@ -900,7 +900,7 @@ pub unsafe fn dc_search_msgs(
     query: *const libc::c_char,
 ) -> *mut dc_array_t {
     let mut success = 0;
-    let mut ret = dc_array_new(100 as size_t);
+    let ret = dc_array_new(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;
@@ -930,7 +930,7 @@ pub unsafe fn dc_search_msgs(
                 sqlite3_bind_text(stmt, 2, strLikeInText, -1, None);
                 sqlite3_bind_text(stmt, 3, strLikeBeg, -1, None);
             } else {
-                let mut show_deaddrop = 0;
+                let show_deaddrop = 0;
                 stmt = dc_sqlite3_prepare(
                     context,
                     &context.sql.clone().read().unwrap(),
@@ -989,7 +989,7 @@ pub unsafe fn dc_is_sentbox(
     context: &dc_context_t,
     folder_name: *const libc::c_char,
 ) -> libc::c_int {
-    let mut sentbox_name = dc_sqlite3_get_config(
+    let sentbox_name = dc_sqlite3_get_config(
         context,
         &context.sql.clone().read().unwrap(),
         b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
@@ -1008,7 +1008,7 @@ pub unsafe fn dc_is_sentbox(
 }
 
 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(
+    let mvbox_name = dc_sqlite3_get_config(
         context,
         &context.sql.clone().read().unwrap(),
         b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
diff --git a/src/dc_dehtml.rs b/src/dc_dehtml.rs
index dd270dacc..9196e76ef 100644
--- a/src/dc_dehtml.rs
+++ b/src/dc_dehtml.rs
@@ -13,7 +13,7 @@ pub struct dehtml_t {
 
 /* ** library-internal *********************************************************/
 /* dc_dehtml() returns way too many lineends; however, an optimisation on this issue is not needed as the lineends are typically remove in further processing by the caller */
-pub unsafe fn dc_dehtml(mut buf_terminated: *mut libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_dehtml(buf_terminated: *mut libc::c_char) -> *mut libc::c_char {
     dc_trim(buf_terminated);
     if *buf_terminated.offset(0isize) as libc::c_int == 0i32 {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
@@ -64,9 +64,9 @@ unsafe fn dehtml_text_cb(
     text: *const libc::c_char,
     _len: libc::c_int,
 ) {
-    let mut dehtml: *mut dehtml_t = userdata as *mut dehtml_t;
+    let dehtml: *mut dehtml_t = userdata as *mut dehtml_t;
     if (*dehtml).add_text != 0i32 {
-        let mut last_added: *mut libc::c_char = dc_strbuilder_cat(&mut (*dehtml).strbuilder, text);
+        let last_added: *mut libc::c_char = dc_strbuilder_cat(&mut (*dehtml).strbuilder, text);
         if (*dehtml).add_text == 1i32 {
             let mut p: *mut libc::c_uchar = last_added as *mut libc::c_uchar;
             while 0 != *p {
@@ -95,7 +95,7 @@ unsafe fn dehtml_text_cb(
         }
     };
 }
-unsafe fn dehtml_endtag_cb(mut userdata: *mut libc::c_void, mut tag: *const libc::c_char) {
+unsafe fn dehtml_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char) {
     let mut dehtml: *mut dehtml_t = userdata as *mut dehtml_t;
     if strcmp(tag, b"p\x00" as *const u8 as *const libc::c_char) == 0i32
         || strcmp(tag, b"div\x00" as *const u8 as *const libc::c_char) == 0i32
@@ -142,9 +142,9 @@ unsafe fn dehtml_endtag_cb(mut userdata: *mut libc::c_void, mut tag: *const libc
     };
 }
 unsafe fn dehtml_starttag_cb(
-    mut userdata: *mut libc::c_void,
-    mut tag: *const libc::c_char,
-    mut attr: *mut *mut libc::c_char,
+    userdata: *mut libc::c_void,
+    tag: *const libc::c_char,
+    attr: *mut *mut libc::c_char,
 ) {
     let mut dehtml: *mut dehtml_t = userdata as *mut dehtml_t;
     if strcmp(tag, b"p\x00" as *const u8 as *const libc::c_char) == 0i32
diff --git a/src/dc_e2ee.rs b/src/dc_e2ee.rs
index d6e5ac0ea..2e1241653 100644
--- a/src/dc_e2ee.rs
+++ b/src/dc_e2ee.rs
@@ -44,28 +44,28 @@ pub struct dc_e2ee_helper_t {
 }
 
 pub unsafe fn dc_e2ee_encrypt(
-    mut context: &dc_context_t,
-    mut recipients_addr: *const clist,
-    mut force_unencrypted: libc::c_int,
-    mut e2ee_guaranteed: libc::c_int,
-    mut min_verified: libc::c_int,
-    mut do_gossip: libc::c_int,
+    context: &dc_context_t,
+    recipients_addr: *const clist,
+    force_unencrypted: libc::c_int,
+    e2ee_guaranteed: libc::c_int,
+    min_verified: libc::c_int,
+    do_gossip: libc::c_int,
     mut in_out_message: *mut mailmime,
     mut helper: *mut dc_e2ee_helper_t,
 ) {
-    let mut p_0: *mut libc::c_char;
-    let mut current_block: u64;
+    let p_0: *mut libc::c_char;
+    let current_block: u64;
     let mut col: libc::c_int = 0i32;
     let mut do_encrypt: libc::c_int = 0i32;
     let mut autocryptheader: *mut dc_aheader_t = dc_aheader_new();
     /*just a pointer into mailmime structure, must not be freed*/
-    let mut imffields_unprotected: *mut mailimf_fields;
-    let mut keyring: *mut dc_keyring_t = dc_keyring_new();
-    let mut sign_key: *mut dc_key_t = dc_key_new();
-    let mut plain: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
+    let imffields_unprotected: *mut mailimf_fields;
+    let keyring: *mut dc_keyring_t = dc_keyring_new();
+    let sign_key: *mut dc_key_t = dc_key_new();
+    let plain: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
     let mut ctext: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut ctext_bytes: size_t = 0i32 as size_t;
-    let mut peerstates = dc_array_new(10i32 as size_t);
+    let peerstates = dc_array_new(10i32 as size_t);
     if !helper.is_null() {
         memset(
             helper as *mut libc::c_void,
@@ -113,13 +113,13 @@ pub unsafe fn dc_e2ee_encrypt(
                     let mut iter1: *mut clistiter;
                     iter1 = (*recipients_addr).first;
                     while !iter1.is_null() {
-                        let mut recipient_addr: *const libc::c_char = (if !iter1.is_null() {
+                        let recipient_addr: *const libc::c_char = (if !iter1.is_null() {
                             (*iter1).data
                         } else {
                             0 as *mut libc::c_void
                         })
                             as *const libc::c_char;
-                        let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+                        let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
                         let mut key_to_use: *mut dc_key_t = 0 as *mut dc_key_t;
                         if !(strcasecmp(recipient_addr, (*autocryptheader).addr) == 0i32) {
                             if 0 != dc_apeerstate_load_by_addr(
@@ -169,10 +169,9 @@ pub unsafe fn dc_e2ee_encrypt(
                         let mut part_to_encrypt: *mut mailmime =
                             (*in_out_message).mm_data.mm_message.mm_msg_mime;
                         (*part_to_encrypt).mm_parent = 0 as *mut mailmime;
-                        let mut imffields_encrypted: *mut mailimf_fields =
-                            mailimf_fields_new_empty();
+                        let imffields_encrypted: *mut mailimf_fields = mailimf_fields_new_empty();
                         /* mailmime_new_message_data() calls mailmime_fields_new_with_version() which would add the unwanted MIME-Version:-header */
-                        let mut message_to_encrypt: *mut mailmime = mailmime_new(
+                        let message_to_encrypt: *mut mailmime = mailmime_new(
                             MAILMIME_MESSAGE as libc::c_int,
                             0 as *const libc::c_char,
                             0i32 as size_t,
@@ -186,16 +185,15 @@ pub unsafe fn dc_e2ee_encrypt(
                             part_to_encrypt,
                         );
                         if 0 != do_gossip {
-                            let mut iCnt: libc::c_int = dc_array_get_cnt(peerstates) as libc::c_int;
+                            let iCnt: libc::c_int = dc_array_get_cnt(peerstates) as libc::c_int;
                             if iCnt > 1i32 {
                                 let mut i: libc::c_int = 0i32;
                                 while i < iCnt {
-                                    let mut p: *mut libc::c_char =
-                                        dc_apeerstate_render_gossip_header(
-                                            dc_array_get_ptr(peerstates, i as size_t)
-                                                as *mut dc_apeerstate_t,
-                                            min_verified,
-                                        );
+                                    let p: *mut libc::c_char = dc_apeerstate_render_gossip_header(
+                                        dc_array_get_ptr(peerstates, i as size_t)
+                                            as *mut dc_apeerstate_t,
+                                        min_verified,
+                                    );
                                     if !p.is_null() {
                                         mailimf_fields_add(
                                             imffields_encrypted,
@@ -216,7 +214,7 @@ pub unsafe fn dc_e2ee_encrypt(
                         let mut cur: *mut clistiter = (*(*imffields_unprotected).fld_list).first;
                         while !cur.is_null() {
                             let mut move_to_encrypted: libc::c_int = 0i32;
-                            let mut field: *mut mailimf_field = (if !cur.is_null() {
+                            let field: *mut mailimf_field = (if !cur.is_null() {
                                 (*cur).data
                             } else {
                                 0 as *mut libc::c_void
@@ -228,7 +226,7 @@ pub unsafe fn dc_e2ee_encrypt(
                                 } else if (*field).fld_type
                                     == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int
                                 {
-                                    let mut opt_field: *mut mailimf_optional_field =
+                                    let opt_field: *mut mailimf_optional_field =
                                         (*field).fld_data.fld_optional_field;
                                     if !opt_field.is_null() && !(*opt_field).fld_name.is_null() {
                                         if strncmp(
@@ -263,7 +261,7 @@ pub unsafe fn dc_e2ee_encrypt(
                                 }
                             }
                         }
-                        let mut subject: *mut mailimf_subject = mailimf_subject_new(dc_strdup(
+                        let subject: *mut mailimf_subject = mailimf_subject_new(dc_strdup(
                             b"...\x00" as *const u8 as *const libc::c_char,
                         ));
                         mailimf_fields_add(
@@ -331,8 +329,7 @@ pub unsafe fn dc_e2ee_encrypt(
                                     as *mut libc::c_char,
                                 -1i32,
                             );
-                            let mut content: *mut mailmime_content =
-                                (*encrypted_part).mm_content_type;
+                            let content: *mut mailmime_content = (*encrypted_part).mm_content_type;
                             clist_insert_after(
                                 (*content).ct_parameters,
                                 (*(*content).ct_parameters).last,
@@ -346,7 +343,7 @@ pub unsafe fn dc_e2ee_encrypt(
                             );
                             static mut version_content: [libc::c_char; 13] =
                                 [86, 101, 114, 115, 105, 111, 110, 58, 32, 49, 13, 10, 0];
-                            let mut version_mime: *mut mailmime = new_data_part(
+                            let version_mime: *mut mailmime = new_data_part(
                                 version_content.as_mut_ptr() as *mut libc::c_void,
                                 strlen(version_content.as_mut_ptr()),
                                 b"application/pgp-encrypted\x00" as *const u8 as *const libc::c_char
@@ -354,7 +351,7 @@ pub unsafe fn dc_e2ee_encrypt(
                                 MAILMIME_MECHANISM_7BIT as libc::c_int,
                             );
                             mailmime_smart_add_part(encrypted_part, version_mime);
-                            let mut ctext_part: *mut mailmime = new_data_part(
+                            let ctext_part: *mut mailmime = new_data_part(
                                 ctext as *mut libc::c_void,
                                 ctext_bytes,
                                 b"application/octet-stream\x00" as *const u8 as *const libc::c_char
@@ -410,21 +407,21 @@ pub unsafe fn dc_e2ee_encrypt(
  * Tools
  ******************************************************************************/
 unsafe fn new_data_part(
-    mut data: *mut libc::c_void,
-    mut data_bytes: size_t,
-    mut default_content_type: *mut libc::c_char,
-    mut default_encoding: libc::c_int,
+    data: *mut libc::c_void,
+    data_bytes: size_t,
+    default_content_type: *mut libc::c_char,
+    default_encoding: libc::c_int,
 ) -> *mut mailmime {
     let mut current_block: u64;
     //char basename_buf[PATH_MAX];
     let mut encoding: *mut mailmime_mechanism;
-    let mut content: *mut mailmime_content;
-    let mut mime: *mut mailmime;
+    let content: *mut mailmime_content;
+    let mime: *mut mailmime;
     //int r;
     //char * dup_filename;
-    let mut mime_fields: *mut mailmime_fields;
-    let mut encoding_type: libc::c_int;
-    let mut content_type_str: *mut libc::c_char;
+    let mime_fields: *mut mailmime_fields;
+    let encoding_type: libc::c_int;
+    let content_type_str: *mut libc::c_char;
     let mut do_encoding: libc::c_int;
     encoding = 0 as *mut mailmime_mechanism;
     if default_content_type.is_null() {
@@ -439,7 +436,7 @@ unsafe fn new_data_part(
     } else {
         do_encoding = 1i32;
         if (*(*content).ct_type).tp_type == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int {
-            let mut composite: *mut mailmime_composite_type;
+            let composite: *mut mailmime_composite_type;
             composite = (*(*content).ct_type).tp_data.tp_composite_type;
             match (*composite).ct_type {
                 1 => {
@@ -520,15 +517,15 @@ unsafe fn new_data_part(
  ******************************************************************************/
 // TODO should return bool /rtn
 unsafe fn load_or_generate_self_public_key(
-    mut context: &dc_context_t,
-    mut public_key: *mut dc_key_t,
-    mut self_addr: *const libc::c_char,
-    mut random_data_mime: *mut mailmime,
+    context: &dc_context_t,
+    public_key: *mut dc_key_t,
+    self_addr: *const libc::c_char,
+    random_data_mime: *mut mailmime,
 ) -> libc::c_int {
     let mut current_block: u64;
     /* avoid double creation (we unlock the database during creation) */
     static mut s_in_key_creation: libc::c_int = 0i32;
-    let mut key_created: libc::c_int;
+    let key_created: libc::c_int;
     let mut success: libc::c_int = 0i32;
     let mut key_creation_here: libc::c_int = 0i32;
     if !public_key.is_null() {
@@ -545,7 +542,7 @@ unsafe fn load_or_generate_self_public_key(
                 key_creation_here = 1i32;
                 s_in_key_creation = 1i32;
                 if !random_data_mime.is_null() {
-                    let mut random_data_mmap: *mut MMAPString;
+                    let random_data_mmap: *mut MMAPString;
                     let mut col: libc::c_int = 0i32;
                     random_data_mmap = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
                     if random_data_mmap.is_null() {
@@ -561,8 +558,8 @@ unsafe fn load_or_generate_self_public_key(
                 match current_block {
                     10496152961502316708 => {}
                     _ => {
-                        let mut private_key: *mut dc_key_t = dc_key_new();
-                        let mut start: libc::clock_t = clock();
+                        let private_key: *mut dc_key_t = dc_key_new();
+                        let start: libc::clock_t = clock();
                         dc_log_info(
                             context,
                             0i32,
@@ -639,22 +636,22 @@ unsafe fn load_or_generate_self_public_key(
 
 /* returns 1 if sth. was decrypted, 0 in other cases */
 pub unsafe fn dc_e2ee_decrypt(
-    mut context: &dc_context_t,
-    mut in_out_message: *mut mailmime,
+    context: &dc_context_t,
+    in_out_message: *mut mailmime,
     mut helper: *mut dc_e2ee_helper_t,
 ) {
     let mut iterations: libc::c_int;
     /* return values: 0=nothing to decrypt/cannot decrypt, 1=sth. decrypted
     (to detect parts that could not be decrypted, simply look for left "multipart/encrypted" MIME types */
     /*just a pointer into mailmime structure, must not be freed*/
-    let mut imffields: *mut mailimf_fields = mailmime_find_mailimf_fields(in_out_message);
+    let imffields: *mut mailimf_fields = mailmime_find_mailimf_fields(in_out_message);
     let mut autocryptheader: *mut dc_aheader_t = 0 as *mut dc_aheader_t;
     let mut message_time: time_t = 0i32 as time_t;
-    let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+    let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
     let mut from: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut private_keyring: *mut dc_keyring_t = dc_keyring_new();
-    let mut public_keyring_for_validate: *mut dc_keyring_t = dc_keyring_new();
+    let private_keyring: *mut dc_keyring_t = dc_keyring_new();
+    let public_keyring_for_validate: *mut dc_keyring_t = dc_keyring_new();
     let mut gossip_headers: *mut mailimf_fields = 0 as *mut mailimf_fields;
     if !helper.is_null() {
         memset(
@@ -672,7 +669,7 @@ pub unsafe fn dc_e2ee_decrypt(
             }
             field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
             if !field.is_null() && !(*field).fld_data.fld_orig_date.is_null() {
-                let mut orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
+                let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
                 if !orig_date.is_null() {
                     message_time = dc_timestamp_from_date((*orig_date).dt_date_time);
                     if message_time != -1i32 as libc::c_long
@@ -779,23 +776,23 @@ pub unsafe fn dc_e2ee_decrypt(
 }
 
 unsafe fn update_gossip_peerstates(
-    mut context: &dc_context_t,
-    mut message_time: time_t,
-    mut imffields: *mut mailimf_fields,
-    mut gossip_headers: *const mailimf_fields,
+    context: &dc_context_t,
+    message_time: time_t,
+    imffields: *mut mailimf_fields,
+    gossip_headers: *const mailimf_fields,
 ) -> *mut dc_hash_t {
     let mut cur1: *mut clistiter;
     let mut recipients: *mut dc_hash_t = 0 as *mut dc_hash_t;
     let mut gossipped_addr: *mut dc_hash_t = 0 as *mut dc_hash_t;
     cur1 = (*(*gossip_headers).fld_list).first;
     while !cur1.is_null() {
-        let mut field: *mut mailimf_field = (if !cur1.is_null() {
+        let field: *mut mailimf_field = (if !cur1.is_null() {
             (*cur1).data
         } else {
             0 as *mut libc::c_void
         }) as *mut mailimf_field;
         if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let mut optional_field: *const mailimf_optional_field =
+            let optional_field: *const mailimf_optional_field =
                 (*field).fld_data.fld_optional_field;
             if !optional_field.is_null()
                 && !(*optional_field).fld_name.is_null()
@@ -804,7 +801,7 @@ unsafe fn update_gossip_peerstates(
                     b"Autocrypt-Gossip\x00" as *const u8 as *const libc::c_char,
                 ) == 0i32
             {
-                let mut gossip_header: *mut dc_aheader_t = dc_aheader_new();
+                let gossip_header: *mut dc_aheader_t = dc_aheader_new();
                 if 0 != dc_aheader_set_from_string(gossip_header, (*optional_field).fld_value)
                     && 0 != dc_pgp_is_valid_key(context, (*gossip_header).public_key)
                 {
@@ -818,7 +815,7 @@ unsafe fn update_gossip_peerstates(
                     )
                     .is_null()
                     {
-                        let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+                        let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
                         if 0 == dc_apeerstate_load_by_addr(
                             peerstate,
                             &context.sql.clone().read().unwrap(),
@@ -882,15 +879,15 @@ unsafe fn update_gossip_peerstates(
 
 // TODO should return bool /rtn
 unsafe fn decrypt_recursive(
-    mut context: &dc_context_t,
-    mut mime: *mut mailmime,
-    mut private_keyring: *const dc_keyring_t,
-    mut public_keyring_for_validate: *const dc_keyring_t,
-    mut ret_valid_signatures: *mut dc_hash_t,
-    mut ret_gossip_headers: *mut *mut mailimf_fields,
-    mut ret_has_unencrypted_parts: *mut libc::c_int,
+    context: &dc_context_t,
+    mime: *mut mailmime,
+    private_keyring: *const dc_keyring_t,
+    public_keyring_for_validate: *const dc_keyring_t,
+    ret_valid_signatures: *mut dc_hash_t,
+    ret_gossip_headers: *mut *mut mailimf_fields,
+    ret_has_unencrypted_parts: *mut libc::c_int,
 ) -> libc::c_int {
-    let mut ct: *mut mailmime_content;
+    let ct: *mut mailmime_content;
     let mut cur: *mut clistiter;
     if mime.is_null() {
         return 0i32;
@@ -989,16 +986,16 @@ unsafe fn decrypt_recursive(
 }
 
 unsafe fn decrypt_part(
-    mut context: &dc_context_t,
-    mut mime: *mut mailmime,
-    mut private_keyring: *const dc_keyring_t,
-    mut public_keyring_for_validate: *const dc_keyring_t,
-    mut ret_valid_signatures: *mut dc_hash_t,
-    mut ret_decrypted_mime: *mut *mut mailmime,
+    context: &dc_context_t,
+    mime: *mut mailmime,
+    private_keyring: *const dc_keyring_t,
+    public_keyring_for_validate: *const dc_keyring_t,
+    ret_valid_signatures: *mut dc_hash_t,
+    ret_decrypted_mime: *mut *mut mailmime,
 ) -> libc::c_int {
-    let mut add_signatures: *mut dc_hash_t;
-    let mut current_block: u64;
-    let mut mime_data: *mut mailmime_data;
+    let add_signatures: *mut dc_hash_t;
+    let current_block: u64;
+    let mime_data: *mut mailmime_data;
     let mut mime_transfer_encoding: libc::c_int = MAILMIME_MECHANISM_BINARY as libc::c_int;
     /* mmap_string_unref()'d if set */
     let mut transfer_decoding_buffer: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -1019,7 +1016,7 @@ unsafe fn decrypt_part(
             let mut cur: *mut clistiter;
             cur = (*(*(*mime).mm_mime_fields).fld_list).first;
             while !cur.is_null() {
-                let mut field: *mut mailmime_field = (if !cur.is_null() {
+                let field: *mut mailmime_field = (if !cur.is_null() {
                     (*cur).data
                 } else {
                     0 as *mut libc::c_void
@@ -1052,7 +1049,7 @@ unsafe fn decrypt_part(
                 current_block = 4488286894823169796;
             }
         } else {
-            let mut r: libc::c_int;
+            let r: libc::c_int;
             let mut current_index: size_t = 0i32 as size_t;
             r = mailmime_part_parse(
                 (*mime_data).dt_data.dt_text.dt_data,
@@ -1136,11 +1133,10 @@ unsafe fn decrypt_part(
  ******************************************************************************/
 // TODO should return bool /rtn
 unsafe fn has_decrypted_pgp_armor(
-    mut str__: *const libc::c_char,
+    str__: *const libc::c_char,
     mut str_bytes: libc::c_int,
 ) -> libc::c_int {
-    let mut str_end: *const libc::c_uchar =
-        (str__ as *const libc::c_uchar).offset(str_bytes as isize);
+    let str_end: *const libc::c_uchar = (str__ as *const libc::c_uchar).offset(str_bytes as isize);
     let mut p: *const libc::c_uchar = str__ as *const libc::c_uchar;
     while p < str_end {
         if *p as libc::c_int > ' ' as i32 {
@@ -1177,7 +1173,7 @@ unsafe fn has_decrypted_pgp_armor(
  * @return 1=multipart/report found in MIME, 0=no multipart/report found
  */
 // TODO should return bool /rtn
-unsafe fn contains_report(mut mime: *mut mailmime) -> libc::c_int {
+unsafe fn contains_report(mime: *mut mailmime) -> libc::c_int {
     if (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int {
         if (*(*(*mime).mm_content_type).ct_type).tp_type
             == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int
@@ -1241,11 +1237,11 @@ pub unsafe fn dc_e2ee_thanks(mut helper: *mut dc_e2ee_helper_t) {
 
 /* makes sure, the private key exists, needed only for exporting keys and the case no message was sent before */
 // TODO should return bool /rtn
-pub unsafe fn dc_ensure_secret_key_exists(mut context: &dc_context_t) -> libc::c_int {
+pub unsafe fn dc_ensure_secret_key_exists(context: &dc_context_t) -> libc::c_int {
     /* normally, the key is generated as soon as the first mail is send
     (this is to gain some extra-random-seed by the message content and the timespan between program start and message sending) */
     let mut success: libc::c_int = 0i32;
-    let mut public_key: *mut dc_key_t = dc_key_new();
+    let public_key: *mut dc_key_t = dc_key_new();
     let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
     if !public_key.is_null() {
         self_addr = dc_sqlite3_get_config(
diff --git a/src/dc_hash.rs b/src/dc_hash.rs
index a0e76d535..d1ae2e4b9 100644
--- a/src/dc_hash.rs
+++ b/src/dc_hash.rs
@@ -70,7 +70,7 @@ pub struct _dc_hashelem {
  */
 pub unsafe fn dc_hash_init(
     mut pNew: *mut dc_hash_t,
-    mut keyClass: libc::c_int,
+    keyClass: libc::c_int,
     mut copyKey: libc::c_int,
 ) {
     if 0 != pNew.is_null() as libc::c_int as libc::c_long {
@@ -107,12 +107,12 @@ pub unsafe fn dc_hash_init(
 
 pub unsafe fn dc_hash_insert(
     mut pH: *mut dc_hash_t,
-    mut pKey: *const libc::c_void,
-    mut nKey: libc::c_int,
-    mut data: *mut libc::c_void,
+    pKey: *const libc::c_void,
+    nKey: libc::c_int,
+    data: *mut libc::c_void,
 ) -> *mut libc::c_void {
     /* Raw hash value of the key */
-    let mut hraw: libc::c_int;
+    let hraw: libc::c_int;
     /* the hash of the key modulo hash table size */
     let mut h: libc::c_int;
     /* Used to loop thru the element list */
@@ -120,7 +120,7 @@ pub unsafe fn dc_hash_insert(
     /* New element added to the pH */
     let mut new_elem: *mut dc_hashelem_t;
     /* The hash function */
-    let mut xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>;
+    let xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>;
     if 0 != pH.is_null() as libc::c_int as libc::c_long {
         __assert_rtn(
             (*::std::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"dc_hash_insert\x00"))
@@ -156,7 +156,7 @@ pub unsafe fn dc_hash_insert(
     h = hraw & (*pH).htsize - 1i32;
     elem = findElementGivenHash(pH, pKey, nKey, h);
     if !elem.is_null() {
-        let mut old_data: *mut libc::c_void = (*elem).data;
+        let old_data: *mut libc::c_void = (*elem).data;
         if data.is_null() {
             removeElementGivenHash(pH, elem, h);
         } else {
@@ -257,14 +257,14 @@ unsafe extern "C" fn insertElement(
  * "new_size" must be a power of 2.  The hash table might fail
  * to resize if sjhashMalloc() fails.
  */
-unsafe fn rehash(mut pH: *mut dc_hash_t, mut new_size: libc::c_int) {
+unsafe fn rehash(mut pH: *mut dc_hash_t, new_size: libc::c_int) {
     /* The new hash table */
-    let mut new_ht: *mut _ht;
+    let new_ht: *mut _ht;
     /* For looping over existing elements */
     let mut elem: *mut dc_hashelem_t;
     let mut next_elem: *mut dc_hashelem_t;
     /* The hash function */
-    let mut xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>;
+    let xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>;
     if 0 != !(new_size & new_size - 1i32 == 0i32) as libc::c_int as libc::c_long {
         __assert_rtn(
             (*::std::mem::transmute::<&[u8; 7], &[libc::c_char; 7]>(b"rehash\x00")).as_ptr(),
@@ -289,7 +289,7 @@ unsafe fn rehash(mut pH: *mut dc_hash_t, mut new_size: libc::c_int) {
     elem = (*pH).first;
     (*pH).first = 0 as *mut dc_hashelem_t;
     while !elem.is_null() {
-        let mut h: libc::c_int =
+        let h: libc::c_int =
             xHash.expect("non-null function pointer")((*elem).pKey, (*elem).nKey) & new_size - 1i32;
         next_elem = (*elem).next;
         insertElement(pH, &mut *new_ht.offset(h as isize), elem);
@@ -307,7 +307,7 @@ unsafe fn rehash(mut pH: *mut dc_hash_t, mut new_size: libc::c_int) {
  * with types "const void*" and "int" and returns an "int".
  */
 unsafe fn hashFunction(
-    mut keyClass: libc::c_int,
+    keyClass: libc::c_int,
 ) -> Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int> {
     match keyClass {
         1 => return Some(intHash),
@@ -322,7 +322,7 @@ unsafe fn hashFunction(
 
 /* Hash and comparison functions when the mode is SJHASH_BINARY
  */
-unsafe fn binHash(mut pKey: *const libc::c_void, mut nKey: libc::c_int) -> libc::c_int {
+unsafe fn binHash(pKey: *const libc::c_void, mut nKey: libc::c_int) -> libc::c_int {
     let mut h: libc::c_int = 0i32;
     let mut z: *const libc::c_char = pKey as *const libc::c_char;
     loop {
@@ -341,7 +341,7 @@ unsafe fn binHash(mut pKey: *const libc::c_void, mut nKey: libc::c_int) -> libc:
 
 /* Hash and comparison functions when the mode is SJHASH_STRING
  */
-unsafe fn strHash(mut pKey: *const libc::c_void, mut nKey: libc::c_int) -> libc::c_int {
+unsafe fn strHash(pKey: *const libc::c_void, nKey: libc::c_int) -> libc::c_int {
     sjhashNoCase(pKey as *const libc::c_char, nKey)
 }
 
@@ -628,13 +628,13 @@ static mut sjhashUpperToLower: [libc::c_uchar; 256] = [
 /* Hash and comparison functions when the mode is SJHASH_POINTER
  */
 unsafe fn ptrHash(pKey: *const libc::c_void, _nKey: libc::c_int) -> libc::c_int {
-    let mut x: uintptr_t = pKey as uintptr_t;
+    let x: uintptr_t = pKey as uintptr_t;
     (x ^ x << 8i32 ^ x >> 8i32) as libc::c_int
 }
 
 /* Hash and comparison functions when the mode is SJHASH_INT
  */
-unsafe fn intHash(_pKey: *const libc::c_void, mut nKey: libc::c_int) -> libc::c_int {
+unsafe fn intHash(_pKey: *const libc::c_void, nKey: libc::c_int) -> libc::c_int {
     nKey ^ nKey << 8i32 ^ nKey >> 8i32
 }
 
@@ -646,8 +646,8 @@ unsafe fn intHash(_pKey: *const libc::c_void, mut nKey: libc::c_int) -> libc::c_
 ** May you find forgiveness for yourself and forgive others.
 ** May you share freely, never taking more than you give.
 */
-unsafe fn sjhashMalloc(mut bytes: libc::c_int) -> *mut libc::c_void {
-    let mut p: *mut libc::c_void = malloc(bytes as size_t);
+unsafe fn sjhashMalloc(bytes: libc::c_int) -> *mut libc::c_void {
+    let p: *mut libc::c_void = malloc(bytes as size_t);
     if !p.is_null() {
         memset(p, 0i32, bytes as size_t);
     }
@@ -660,7 +660,7 @@ unsafe fn sjhashMalloc(mut bytes: libc::c_int) -> *mut libc::c_void {
 unsafe fn removeElementGivenHash(
     mut pH: *mut dc_hash_t,
     mut elem: *mut dc_hashelem_t,
-    mut h: libc::c_int,
+    h: libc::c_int,
 ) {
     let mut pEntry: *mut _ht;
     if !(*elem).prev.is_null() {
@@ -691,17 +691,17 @@ unsafe fn removeElementGivenHash(
  * already been computed and is passed as the 4th parameter.
  */
 unsafe fn findElementGivenHash(
-    mut pH: *const dc_hash_t,
-    mut pKey: *const libc::c_void,
-    mut nKey: libc::c_int,
-    mut h: libc::c_int,
+    pH: *const dc_hash_t,
+    pKey: *const libc::c_void,
+    nKey: libc::c_int,
+    h: libc::c_int,
 ) -> *mut dc_hashelem_t {
     /* Used to loop thru the element list */
     let mut elem: *mut dc_hashelem_t;
     /* Number of elements left to test */
     let mut count: libc::c_int;
     /* comparison function */
-    let mut xCompare: Option<
+    let xCompare: Option<
         unsafe fn(
             _: *const libc::c_void,
             _: libc::c_int,
@@ -710,7 +710,7 @@ unsafe fn findElementGivenHash(
         ) -> libc::c_int,
     >;
     if !(*pH).ht.is_null() {
-        let mut pEntry: *mut _ht = &mut *(*pH).ht.offset(h as isize) as *mut _ht;
+        let pEntry: *mut _ht = &mut *(*pH).ht.offset(h as isize) as *mut _ht;
         elem = (*pEntry).chain;
         count = (*pEntry).count;
         xCompare = compareFunction((*pH).keyClass as libc::c_int);
@@ -735,7 +735,7 @@ unsafe fn findElementGivenHash(
 /* Return a pointer to the appropriate hash function given the key class.
  */
 unsafe fn compareFunction(
-    mut keyClass: libc::c_int,
+    keyClass: libc::c_int,
 ) -> Option<
     unsafe fn(
         _: *const libc::c_void,
@@ -755,10 +755,10 @@ unsafe fn compareFunction(
 }
 
 unsafe fn binCompare(
-    mut pKey1: *const libc::c_void,
-    mut n1: libc::c_int,
-    mut pKey2: *const libc::c_void,
-    mut n2: libc::c_int,
+    pKey1: *const libc::c_void,
+    n1: libc::c_int,
+    pKey2: *const libc::c_void,
+    n2: libc::c_int,
 ) -> libc::c_int {
     if n1 != n2 {
         return 1i32;
@@ -767,10 +767,10 @@ unsafe fn binCompare(
 }
 
 unsafe fn strCompare(
-    mut pKey1: *const libc::c_void,
-    mut n1: libc::c_int,
-    mut pKey2: *const libc::c_void,
-    mut n2: libc::c_int,
+    pKey1: *const libc::c_void,
+    n1: libc::c_int,
+    pKey2: *const libc::c_void,
+    n2: libc::c_int,
 ) -> libc::c_int {
     if n1 != n2 {
         return 1i32;
@@ -786,8 +786,8 @@ unsafe fn strCompare(
  * there is no consistency, we will define our own.
  */
 unsafe fn sjhashStrNICmp(
-    mut zLeft: *const libc::c_char,
-    mut zRight: *const libc::c_char,
+    zLeft: *const libc::c_char,
+    zRight: *const libc::c_char,
     mut N: libc::c_int,
 ) -> libc::c_int {
     let mut a: *mut libc::c_uchar;
@@ -840,16 +840,16 @@ unsafe fn intCompare(
 }
 
 pub unsafe fn dc_hash_find(
-    mut pH: *const dc_hash_t,
-    mut pKey: *const libc::c_void,
-    mut nKey: libc::c_int,
+    pH: *const dc_hash_t,
+    pKey: *const libc::c_void,
+    nKey: libc::c_int,
 ) -> *mut libc::c_void {
     /* A hash on key */
-    let mut h: libc::c_int;
+    let h: libc::c_int;
     /* The element that matches key */
-    let mut elem: *mut dc_hashelem_t;
+    let elem: *mut dc_hashelem_t;
     /* The hash function */
-    let mut xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>;
+    let xHash: Option<unsafe fn(_: *const libc::c_void, _: libc::c_int) -> libc::c_int>;
     if pH.is_null() || (*pH).ht.is_null() {
         return 0 as *mut libc::c_void;
     }
@@ -897,7 +897,7 @@ pub unsafe fn dc_hash_clear(mut pH: *mut dc_hash_t) {
     (*pH).ht = 0 as *mut _ht;
     (*pH).htsize = 0i32;
     while !elem.is_null() {
-        let mut next_elem: *mut dc_hashelem_t = (*elem).next;
+        let next_elem: *mut dc_hashelem_t = (*elem).next;
         if 0 != (*pH).copyKey as libc::c_int && !(*elem).pKey.is_null() {
             free((*elem).pKey);
         }
diff --git a/src/dc_imap.rs b/src/dc_imap.rs
index 75f93c2bb..cb9be2aaa 100644
--- a/src/dc_imap.rs
+++ b/src/dc_imap.rs
@@ -291,7 +291,7 @@ pub struct ImapConfig {
 
 impl Default for ImapConfig {
     fn default() -> Self {
-        let mut cfg = ImapConfig {
+        let cfg = ImapConfig {
             addr: None,
             imap_server: None,
             imap_port: None,
@@ -447,7 +447,7 @@ impl Imap {
     }
 
     pub fn disconnect(&self, context: &dc_context_t) {
-        let mut session = self.session.lock().unwrap().take();
+        let session = self.session.lock().unwrap().take();
         if session.is_some() {
             match session.unwrap().close() {
                 Ok(_) => {}
@@ -955,7 +955,7 @@ impl Imap {
     fn fake_idle(&self, context: &dc_context_t) {
         // Idle using timeouts. This is also needed if we're not yet configured -
         // in this case, we're waiting for a configure job
-        let mut fake_idle_start_time = SystemTime::now();
+        let fake_idle_start_time = SystemTime::now();
 
         info!(context, 0, "IMAP-fake-IDLEing...");
 
@@ -1186,7 +1186,7 @@ impl Imap {
     pub fn set_mdnsent<S: AsRef<str>>(&self, context: &dc_context_t, folder: S, uid: u32) -> usize {
         // returns 0=job should be retried later, 1=job done, 2=job done and flag just set
         let mut res = DC_RETRY_LATER;
-        let mut set = format!("{}", uid);
+        let set = format!("{}", uid);
 
         if uid == 0 {
             res = DC_FAILED;
@@ -1400,7 +1400,7 @@ impl Imap {
             .find(|folder| folder.name() == "DeltaChat" || folder.name() == fallback_folder)
             .map(|n| n.name().to_string());
 
-        let mut sentbox_folder = folders
+        let sentbox_folder = folders
             .iter()
             .find(|folder| match get_folder_meaning(folder) {
                 FolderMeaning::SentObjects => true,
diff --git a/src/dc_imex.rs b/src/dc_imex.rs
index 3f2a0a001..b5a8aca02 100644
--- a/src/dc_imex.rs
+++ b/src/dc_imex.rs
@@ -28,12 +28,12 @@ use crate::x::*;
 // param1 is a directory where the backup is written to
 // param1 is the file with the backup to import
 pub unsafe fn dc_imex(
-    mut context: &dc_context_t,
-    mut what: libc::c_int,
-    mut param1: *const libc::c_char,
-    mut param2: *const libc::c_char,
+    context: &dc_context_t,
+    what: libc::c_int,
+    param1: *const libc::c_char,
+    param2: *const libc::c_char,
 ) {
-    let mut param: *mut dc_param_t = dc_param_new();
+    let param: *mut dc_param_t = dc_param_new();
     dc_param_set_int(param, 'S' as i32, what);
     dc_param_set(param, 'E' as i32, param1);
     dc_param_set(param, 'F' as i32, param2);
@@ -43,15 +43,15 @@ pub unsafe fn dc_imex(
 }
 
 pub unsafe fn dc_imex_has_backup(
-    mut context: &dc_context_t,
-    mut dir_name: *const libc::c_char,
+    context: &dc_context_t,
+    dir_name: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut ret_backup_time: time_t = 0i32 as time_t;
-    let mut dir_handle: *mut DIR;
+    let dir_handle: *mut DIR;
     let mut dir_entry: *mut dirent;
-    let mut prefix_len = strlen(b"delta-chat\x00" as *const u8 as *const libc::c_char);
-    let mut suffix_len = strlen(b"bak\x00" as *const u8 as *const libc::c_char);
+    let prefix_len = strlen(b"delta-chat\x00" as *const u8 as *const libc::c_char);
+    let suffix_len = strlen(b"bak\x00" as *const u8 as *const libc::c_char);
     let mut curr_pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut test_sql: Option<dc_sqlite3_t> = None;
     dir_handle = opendir(dir_name);
@@ -68,8 +68,8 @@ pub unsafe fn dc_imex_has_backup(
             if dir_entry.is_null() {
                 break;
             }
-            let mut name: *const libc::c_char = (*dir_entry).d_name.as_mut_ptr();
-            let mut name_len = strlen(name);
+            let name: *const libc::c_char = (*dir_entry).d_name.as_mut_ptr();
+            let name_len = strlen(name);
             if name_len > prefix_len
                 && strncmp(
                     name,
@@ -95,7 +95,7 @@ pub unsafe fn dc_imex_has_backup(
                 }
                 let mut sql = dc_sqlite3_new();
                 if 0 != dc_sqlite3_open(context, &mut sql, curr_pathNfilename, 0x1i32) {
-                    let mut curr_backup_time: time_t = dc_sqlite3_get_config_int(
+                    let curr_backup_time: time_t = dc_sqlite3_get_config_int(
                         context,
                         &mut sql,
                         b"backup_time\x00" as *const u8 as *const libc::c_char,
@@ -124,13 +124,13 @@ pub unsafe fn dc_imex_has_backup(
 }
 
 pub unsafe fn dc_check_password(
-    mut context: &dc_context_t,
-    mut test_pw: *const libc::c_char,
+    context: &dc_context_t,
+    test_pw: *const libc::c_char,
 ) -> libc::c_int {
     /* Check if the given password matches the configured mail_pw.
     This is to prompt the user before starting eg. an export; this is mainly to avoid doing people bad thinkgs if they have short access to the device.
     When we start supporting OAuth some day, we should think this over, maybe force the user to re-authenticate himself with the Android password. */
-    let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new();
+    let loginparam: *mut dc_loginparam_t = dc_loginparam_new();
     let mut success: libc::c_int = 0i32;
 
     dc_loginparam_read(
@@ -155,15 +155,15 @@ pub unsafe fn dc_check_password(
     success
 }
 
-pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc::c_char {
-    let mut current_block: u64;
+pub unsafe fn dc_initiate_key_transfer(context: &dc_context_t) -> *mut libc::c_char {
+    let current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut setup_code: *mut libc::c_char;
     let mut setup_file_content: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut setup_file_name: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut chat_id: uint32_t;
+    let chat_id: uint32_t;
     let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
-    let mut msg_id: uint32_t;
+    let msg_id: uint32_t;
     if 0 == dc_alloc_ongoing(context) {
         return 0 as *mut libc::c_char;
     }
@@ -283,12 +283,12 @@ pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc:
 }
 
 pub unsafe extern "C" fn dc_render_setup_file(
-    mut context: &dc_context_t,
-    mut passphrase: *const libc::c_char,
+    context: &dc_context_t,
+    passphrase: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut curr_private_key: *mut dc_key_t = dc_key_new();
+    let curr_private_key: *mut dc_key_t = dc_key_new();
     let mut passphrase_begin: [libc::c_char; 8] = [0; 8];
     let mut encr_string: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut ret_setupfilecontent: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -309,13 +309,13 @@ pub unsafe extern "C" fn dc_render_setup_file(
                 self_addr,
                 &context.sql.clone().read().unwrap(),
             );
-            let mut e2ee_enabled: libc::c_int = dc_sqlite3_get_config_int(
+            let e2ee_enabled: libc::c_int = dc_sqlite3_get_config_int(
                 context,
                 &context.sql.clone().read().unwrap(),
                 b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
                 1i32,
             );
-            let mut payload_key_asc: *mut libc::c_char = dc_key_render_asc(
+            let payload_key_asc: *mut libc::c_char = dc_key_render_asc(
                 curr_private_key,
                 if 0 != e2ee_enabled {
                     Some(("Autocrypt-Prefer-Encrypt", "mutual"))
@@ -334,7 +334,7 @@ pub unsafe extern "C" fn dc_render_setup_file(
                     ))
                 {
                     free(payload_key_asc as *mut libc::c_void);
-                    let mut replacement: *mut libc::c_char =
+                    let  replacement: *mut libc::c_char =
                         dc_mprintf(b"-----BEGIN PGP MESSAGE-----\r\nPassphrase-Format: numeric9x4\r\nPassphrase-Begin: %s\x00"
                                        as *const u8 as *const libc::c_char,
                                    passphrase_begin.as_mut_ptr());
@@ -344,7 +344,7 @@ pub unsafe extern "C" fn dc_render_setup_file(
                         replacement,
                     );
                     free(replacement as *mut libc::c_void);
-                    let mut setup_message_title: *mut libc::c_char = dc_stock_str(context, 42i32);
+                    let setup_message_title: *mut libc::c_char = dc_stock_str(context, 42i32);
                     let mut setup_message_body: *mut libc::c_char = dc_stock_str(context, 43i32);
                     dc_str_replace(
                         &mut setup_message_body,
@@ -413,9 +413,9 @@ pub unsafe fn dc_create_setup_code(_context: &dc_context_t) -> *mut libc::c_char
 
 // TODO should return bool /rtn
 pub unsafe fn dc_continue_key_transfer(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-    mut setup_code: *const libc::c_char,
+    context: &dc_context_t,
+    msg_id: uint32_t,
+    setup_code: *const libc::c_char,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
@@ -491,20 +491,20 @@ pub unsafe fn dc_continue_key_transfer(
 
 // TODO should return bool /rtn
 unsafe fn set_self_key(
-    mut context: &dc_context_t,
-    mut armored: *const libc::c_char,
-    mut set_default: libc::c_int,
+    context: &dc_context_t,
+    armored: *const libc::c_char,
+    set_default: libc::c_int,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
-    let mut buf: *mut libc::c_char;
+    let buf: *mut libc::c_char;
     // pointer inside buf, MUST NOT be free()'d
     let mut buf_headerline: *const libc::c_char = 0 as *const libc::c_char;
     //   - " -
     let mut buf_preferencrypt: *const libc::c_char = 0 as *const libc::c_char;
     //   - " -
     let mut buf_base64: *const libc::c_char = 0 as *const libc::c_char;
-    let mut private_key: *mut dc_key_t = dc_key_new();
-    let mut public_key: *mut dc_key_t = dc_key_new();
+    let private_key: *mut dc_key_t = dc_key_new();
+    let public_key: *mut dc_key_t = dc_key_new();
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
     buf = dc_strdup(armored);
@@ -617,11 +617,11 @@ unsafe fn set_self_key(
 }
 
 pub unsafe fn dc_decrypt_setup_file(
-    mut context: &dc_context_t,
-    mut passphrase: *const libc::c_char,
-    mut filecontent: *const libc::c_char,
+    context: &dc_context_t,
+    passphrase: *const libc::c_char,
+    filecontent: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut fc_buf: *mut libc::c_char;
+    let fc_buf: *mut libc::c_char;
     let mut fc_headerline: *const libc::c_char = 0 as *const libc::c_char;
     let mut fc_base64: *const libc::c_char = 0 as *const libc::c_char;
     let mut binary: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -724,11 +724,11 @@ pub unsafe fn dc_normalize_setup_code(
     out.buf
 }
 
-pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(mut context: &dc_context_t, mut job: *mut dc_job_t) {
+pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(context: &dc_context_t, job: *mut dc_job_t) {
     let mut current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut ongoing_allocated_here: libc::c_int = 0i32;
-    let mut what: libc::c_int;
+    let what: libc::c_int;
     let mut param1: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut param2: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(0 == dc_alloc_ongoing(context)) {
@@ -985,17 +985,17 @@ pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(mut context: &dc_context_t, mut job: *m
 
 // TODO should return bool /rtn
 unsafe fn import_backup(
-    mut context: &dc_context_t,
-    mut backup_to_import: *const libc::c_char,
+    context: &dc_context_t,
+    backup_to_import: *const libc::c_char,
 ) -> libc::c_int {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut processed_files_cnt: libc::c_int = 0i32;
-    let mut total_files_cnt: libc::c_int;
+    let total_files_cnt: libc::c_int;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut repl_from: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut repl_to: *mut libc::c_char = 0 as *mut libc::c_char;
+    let repl_from: *mut libc::c_char = 0 as *mut libc::c_char;
+    let repl_to: *mut libc::c_char = 0 as *mut libc::c_char;
     dc_log_info(
         context,
         0i32,
@@ -1075,10 +1075,10 @@ unsafe fn import_backup(
                         permille as uintptr_t,
                         0i32 as uintptr_t,
                     );
-                    let mut file_name: *const libc::c_char =
+                    let file_name: *const libc::c_char =
                         sqlite3_column_text(stmt, 0i32) as *const libc::c_char;
-                    let mut file_bytes: libc::c_int = sqlite3_column_bytes(stmt, 1i32);
-                    let mut file_content: *const libc::c_void = sqlite3_column_blob(stmt, 1i32);
+                    let file_bytes: libc::c_int = sqlite3_column_bytes(stmt, 1i32);
+                    let file_content: *const libc::c_void = sqlite3_column_blob(stmt, 1i32);
                     if !(file_bytes > 0i32 && !file_content.is_null()) {
                         continue;
                     }
@@ -1145,16 +1145,16 @@ unsafe fn import_backup(
 /* the FILE_PROGRESS macro calls the callback with the permille of files processed.
 The macro avoids weird values of 0% or 100% while still working. */
 // TODO should return bool /rtn
-unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char) -> libc::c_int {
+unsafe fn export_backup(context: &dc_context_t, dir: *const libc::c_char) -> libc::c_int {
     let mut current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut closed: libc::c_int = 0i32;
-    let mut dest_pathNfilename: *mut libc::c_char;
+    let dest_pathNfilename: *mut libc::c_char;
     let mut now = time(0 as *mut time_t);
     let mut dir_handle: *mut DIR = 0 as *mut DIR;
     let mut dir_entry: *mut dirent;
-    let mut prefix_len = strlen(b"delta-chat\x00" as *const u8 as *const libc::c_char);
-    let mut suffix_len = strlen(b"bak\x00" as *const u8 as *const libc::c_char);
+    let prefix_len = strlen(b"delta-chat\x00" as *const u8 as *const libc::c_char);
+    let suffix_len = strlen(b"bak\x00" as *const u8 as *const libc::c_char);
     let mut curr_pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut buf: *mut libc::c_void = 0 as *mut libc::c_void;
     let mut buf_bytes: size_t = 0i32 as size_t;
@@ -1165,7 +1165,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
     let mut dest_sql: Option<dc_sqlite3_t> = None;
     /* get a fine backup file name (the name includes the date so that multiple backup instances are possible)
     FIXME: we should write to a temporary file first and rename it on success. this would guarantee the backup is complete. however, currently it is not clear it the import exists in the long run (may be replaced by a restore-from-imap)*/
-    let mut timeinfo: *mut tm;
+    let timeinfo: *mut tm;
     let mut buffer: [libc::c_char; 256] = [0; 256];
     timeinfo = localtime(&mut now);
     strftime(
@@ -1305,9 +1305,9 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
                                                 0i32 as uintptr_t,
                                             );
                                             /* name without path; may also be `.` or `..` */
-                                            let mut name: *mut libc::c_char =
+                                            let name: *mut libc::c_char =
                                                 (*dir_entry).d_name.as_mut_ptr();
-                                            let mut name_len = strlen(name);
+                                            let name_len = strlen(name);
                                             if !(name_len == 1
                                                 && *name.offset(0isize) as libc::c_int
                                                     == '.' as i32
@@ -1443,10 +1443,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
 /*******************************************************************************
  * Classic key import
  ******************************************************************************/
-unsafe fn import_self_keys(
-    mut context: &dc_context_t,
-    mut dir_name: *const libc::c_char,
-) -> libc::c_int {
+unsafe fn import_self_keys(context: &dc_context_t, dir_name: *const libc::c_char) -> libc::c_int {
     /* hint: even if we switch to import Autocrypt Setup Files, we should leave the possibility to import
     plain ASC keys, at least keys without a password, if we do not want to implement a password entry function.
     Importing ASC keys is useful to use keys in Delta Chat used by any other non-Autocrypt-PGP implementation.
@@ -1577,16 +1574,13 @@ unsafe fn import_self_keys(
 }
 
 // TODO should return bool /rtn
-unsafe fn export_self_keys(
-    mut context: &dc_context_t,
-    mut dir: *const libc::c_char,
-) -> libc::c_int {
+unsafe fn export_self_keys(context: &dc_context_t, dir: *const libc::c_char) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut export_errors: libc::c_int = 0i32;
     let mut id: libc::c_int;
     let mut is_default: libc::c_int;
-    let mut public_key: *mut dc_key_t = dc_key_new();
-    let mut private_key: *mut dc_key_t = dc_key_new();
+    let public_key: *mut dc_key_t = dc_key_new();
+    let private_key: *mut dc_key_t = dc_key_new();
     let stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -1622,14 +1616,14 @@ unsafe fn export_self_keys(
  ******************************************************************************/
 // TODO should return bool /rtn
 unsafe fn export_key_to_asc_file(
-    mut context: &dc_context_t,
-    mut dir: *const libc::c_char,
-    mut id: libc::c_int,
-    mut key: *const dc_key_t,
-    mut is_default: libc::c_int,
+    context: &dc_context_t,
+    dir: *const libc::c_char,
+    id: libc::c_int,
+    key: *const dc_key_t,
+    is_default: libc::c_int,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
-    let mut file_name;
+    let file_name;
     if 0 != is_default {
         file_name = dc_mprintf(
             b"%s/%s-key-default.asc\x00" as *const u8 as *const libc::c_char,
diff --git a/src/dc_job.rs b/src/dc_job.rs
index d5e3be782..28c228a25 100644
--- a/src/dc_job.rs
+++ b/src/dc_job.rs
@@ -66,11 +66,7 @@ pub unsafe fn dc_perform_imap_jobs(context: &dc_context_t) {
         b"INBOX-jobs ended.\x00" as *const u8 as *const libc::c_char,
     );
 }
-unsafe fn dc_job_perform(
-    context: &dc_context_t,
-    mut thread: libc::c_int,
-    mut probe_network: libc::c_int,
-) {
+unsafe fn dc_job_perform(context: &dc_context_t, thread: libc::c_int, probe_network: libc::c_int) {
     let mut select_stmt: *mut sqlite3_stmt;
     let mut job = dc_job_t {
         job_id: 0,
@@ -213,10 +209,10 @@ unsafe fn dc_job_perform(
                 job.job_id as libc::c_int,
             );
         } else if job.try_again == -1i32 || job.try_again == 3i32 {
-            let mut tries_0: libc::c_int = job.tries + 1i32;
+            let tries_0: libc::c_int = job.tries + 1i32;
             if tries_0 < 17i32 {
                 job.tries = tries_0;
-                let mut time_offset: time_t = get_backoff_time_offset(tries_0);
+                let time_offset: time_t = get_backoff_time_offset(tries_0);
                 job.desired_timestamp = job.added_timestamp + time_offset;
                 dc_job_update(context, &mut job);
                 dc_log_info(context, 0i32,
@@ -265,7 +261,7 @@ unsafe fn dc_job_perform(
 }
 
 unsafe fn dc_job_delete(context: &dc_context_t, job: &dc_job_t) {
-    let mut delete_stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let delete_stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"DELETE FROM jobs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
@@ -278,7 +274,7 @@ unsafe fn dc_job_delete(context: &dc_context_t, job: &dc_job_t) {
 /* ******************************************************************************
  * Tools
  ******************************************************************************/
-unsafe fn get_backoff_time_offset(mut c_tries: libc::c_int) -> time_t {
+unsafe fn get_backoff_time_offset(c_tries: libc::c_int) -> time_t {
     // results in ~3 weeks for the last backoff timespan
     let mut N: time_t = pow(2i32 as libc::c_double, (c_tries - 1i32) as libc::c_double) as time_t;
     N = N * 60i32 as libc::c_long;
@@ -291,7 +287,7 @@ unsafe fn get_backoff_time_offset(mut c_tries: libc::c_int) -> time_t {
     return seconds;
 }
 unsafe fn dc_job_update(context: &dc_context_t, job: &dc_job_t) {
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE jobs SET desired_timestamp=?, tries=?, param=? WHERE id=?;\x00" as *const u8
@@ -304,7 +300,7 @@ unsafe fn dc_job_update(context: &dc_context_t, job: &dc_job_t) {
     sqlite3_step(stmt);
     sqlite3_finalize(stmt);
 }
-unsafe fn dc_suspend_smtp_thread(mut context: &dc_context_t, mut suspend: libc::c_int) {
+unsafe fn dc_suspend_smtp_thread(context: &dc_context_t, suspend: libc::c_int) {
     context.smtp_state.clone().0.lock().unwrap().suspended = suspend;
     if 0 != suspend {
         loop {
@@ -324,14 +320,14 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(context: &dc_context_t, job: &mut dc_
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     /* connect to SMTP server, if not yet done */
     if !context.smtp.clone().lock().unwrap().is_connected() {
-        let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new();
+        let loginparam: *mut dc_loginparam_t = dc_loginparam_new();
         dc_loginparam_read(
             context,
             loginparam,
             &context.sql.clone().read().unwrap(),
             b"configured_\x00" as *const u8 as *const libc::c_char,
         );
-        let mut connected = context
+        let connected = context
             .smtp
             .clone()
             .lock()
@@ -427,7 +423,7 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(context: &dc_context_t, job: &mut dc_
                                             as *const libc::c_char,
                                     );
                                     sqlite3_bind_int(stmt, 1i32, job.foreign_id as libc::c_int);
-                                    let mut chat_id: libc::c_int = if sqlite3_step(stmt) == 100i32 {
+                                    let chat_id: libc::c_int = if sqlite3_step(stmt) == 100i32 {
                                         sqlite3_column_int(stmt, 0i32)
                                     } else {
                                         0i32
@@ -465,7 +461,7 @@ pub unsafe fn dc_job_try_again_later(
 
 unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &dc_context_t, job: &mut dc_job_t) {
     let mut current_block: u64;
-    let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
+    let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let mut dest_folder: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut dest_uid: uint32_t = 0i32 as uint32_t;
 
@@ -555,7 +551,7 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &dc_context_t, job: &mut dc_job_t)
  * IMAP-jobs
  ******************************************************************************/
 unsafe fn connect_to_inbox(context: &dc_context_t, inbox: &Imap) -> libc::c_int {
-    let mut ret_connected: libc::c_int;
+    let ret_connected: libc::c_int;
 
     ret_connected = dc_connect_to_configured_imap(context, inbox);
     if !(0 == ret_connected) {
@@ -565,13 +561,12 @@ unsafe fn connect_to_inbox(context: &dc_context_t, inbox: &Imap) -> libc::c_int
 }
 
 unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &dc_context_t, job: &mut dc_job_t) {
-    let mut current_block: u64;
-    let mut folder: *mut libc::c_char =
-        dc_param_get(job.param, 'Z' as i32, 0 as *const libc::c_char);
-    let mut uid: uint32_t = dc_param_get_int(job.param, 'z' as i32, 0i32) as uint32_t;
+    let current_block: u64;
+    let folder: *mut libc::c_char = dc_param_get(job.param, 'Z' as i32, 0 as *const libc::c_char);
+    let uid: uint32_t = dc_param_get_int(job.param, 'z' as i32, 0i32) as uint32_t;
     let mut dest_folder: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut dest_uid: uint32_t = 0i32 as uint32_t;
-    let mut inbox = context.inbox.read().unwrap();
+    let inbox = context.inbox.read().unwrap();
 
     if !inbox.is_connected() {
         connect_to_inbox(context, &inbox);
@@ -622,7 +617,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &dc_context_t, job: &mu
 }
 unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &dc_context_t, job: &mut dc_job_t) {
     let mut current_block: u64;
-    let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
+    let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let inbox = context.inbox.read().unwrap();
 
     if !inbox.is_connected() {
@@ -762,7 +757,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &dc_context_t, job: &mu
     }
     dc_msg_unref(msg);
 }
-unsafe fn dc_send_mdn(mut context: &dc_context_t, mut msg_id: uint32_t) {
+unsafe fn dc_send_mdn(context: &dc_context_t, msg_id: uint32_t) {
     let mut mimefactory: dc_mimefactory_t = dc_mimefactory_t {
         from_addr: 0 as *mut libc::c_char,
         from_displayname: 0 as *mut libc::c_char,
@@ -805,14 +800,14 @@ unsafe fn dc_send_mdn(mut context: &dc_context_t, mut msg_id: uint32_t) {
  * @return 1=success, 0=error
  */
 unsafe fn dc_add_smtp_job(
-    mut context: &dc_context_t,
-    mut action: libc::c_int,
-    mut mimefactory: *mut dc_mimefactory_t,
+    context: &dc_context_t,
+    action: libc::c_int,
+    mimefactory: *mut dc_mimefactory_t,
 ) -> libc::c_int {
-    let mut pathNfilename: *mut libc::c_char;
+    let pathNfilename: *mut libc::c_char;
     let mut success: libc::c_int = 0i32;
     let mut recipients: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut param: *mut dc_param_t = dc_param_new();
+    let param: *mut dc_param_t = dc_param_new();
     pathNfilename = dc_get_fine_pathNfilename(
         context,
         b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
@@ -869,15 +864,15 @@ unsafe fn dc_add_smtp_job(
     return success;
 }
 pub unsafe fn dc_job_add(
-    mut context: &dc_context_t,
-    mut action: libc::c_int,
-    mut foreign_id: libc::c_int,
-    mut param: *const libc::c_char,
-    mut delay_seconds: libc::c_int,
+    context: &dc_context_t,
+    action: libc::c_int,
+    foreign_id: libc::c_int,
+    param: *const libc::c_char,
+    delay_seconds: libc::c_int,
 ) {
-    let mut timestamp: time_t = time(0 as *mut time_t);
-    let mut stmt: *mut sqlite3_stmt;
-    let mut thread: libc::c_int;
+    let timestamp: time_t = time(0 as *mut time_t);
+    let stmt: *mut sqlite3_stmt;
+    let thread: libc::c_int;
     if action >= 100i32 && action < 100i32 + 1000i32 {
         thread = 100i32
     } else if action >= 5000i32 && action < 5000i32 + 1000i32 {
@@ -919,7 +914,7 @@ pub unsafe fn dc_job_add(
         dc_interrupt_smtp_idle(context);
     };
 }
-pub unsafe fn dc_interrupt_smtp_idle(mut context: &dc_context_t) {
+pub unsafe fn dc_interrupt_smtp_idle(context: &dc_context_t) {
     dc_log_info(
         context,
         0i32,
@@ -948,7 +943,7 @@ pub unsafe fn dc_interrupt_imap_idle(context: &dc_context_t) {
 unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context: &dc_context_t, job: &mut dc_job_t) {
     let mut current_block: u64;
     let mut delete_from_server: libc::c_int = 1i32;
-    let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
+    let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let inbox = context.inbox.read().unwrap();
 
     if !(0 == dc_msg_load_from_db(msg, context, job.foreign_id)
@@ -1005,8 +1000,8 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context: &dc_context_t, job: &mut
 }
 
 /* delete all pending jobs with the given action */
-pub unsafe fn dc_job_kill_action(mut context: &dc_context_t, mut action: libc::c_int) {
-    let mut stmt = dc_sqlite3_prepare(
+pub unsafe fn dc_job_kill_action(context: &dc_context_t, action: libc::c_int) {
+    let stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"DELETE FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char,
@@ -1019,7 +1014,7 @@ pub unsafe fn dc_job_kill_action(mut context: &dc_context_t, mut action: libc::c
 pub unsafe fn dc_perform_imap_fetch(context: &dc_context_t) {
     let inbox = context.inbox.read().unwrap();
 
-    let mut start: libc::clock_t = clock();
+    let start: libc::clock_t = clock();
     if 0 == connect_to_inbox(context, &inbox) {
         return;
     }
@@ -1087,7 +1082,7 @@ pub unsafe fn dc_perform_imap_idle(context: &dc_context_t) {
 }
 
 pub unsafe fn dc_perform_mvbox_fetch(context: &dc_context_t) {
-    let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
+    let use_network: libc::c_int = dc_sqlite3_get_config_int(
         context,
         &context.sql.clone().read().unwrap(),
         b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
@@ -1101,7 +1096,7 @@ pub unsafe fn dc_perform_mvbox_fetch(context: &dc_context_t) {
 }
 
 pub unsafe fn dc_perform_mvbox_idle(context: &dc_context_t) {
-    let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
+    let use_network: libc::c_int = dc_sqlite3_get_config_int(
         context,
         &context.sql.clone().read().unwrap(),
         b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
@@ -1119,7 +1114,7 @@ pub unsafe fn dc_interrupt_mvbox_idle(context: &dc_context_t) {
 }
 
 pub unsafe fn dc_perform_sentbox_fetch(context: &dc_context_t) {
-    let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
+    let use_network: libc::c_int = dc_sqlite3_get_config_int(
         context,
         &context.sql.clone().read().unwrap(),
         b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
@@ -1133,7 +1128,7 @@ pub unsafe fn dc_perform_sentbox_fetch(context: &dc_context_t) {
 }
 
 pub unsafe fn dc_perform_sentbox_idle(context: &dc_context_t) {
-    let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
+    let use_network: libc::c_int = dc_sqlite3_get_config_int(
         context,
         &context.sql.clone().read().unwrap(),
         b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
@@ -1191,7 +1186,7 @@ pub unsafe fn dc_perform_smtp_jobs(context: &dc_context_t) {
     }
 }
 
-pub unsafe fn dc_perform_smtp_idle(mut context: &dc_context_t) {
+pub unsafe fn dc_perform_smtp_idle(context: &dc_context_t) {
     dc_log_info(
         context,
         0i32,
@@ -1257,7 +1252,7 @@ unsafe fn get_next_wakeup_time(context: &dc_context_t, thread: libc::c_int) -> D
     wakeup_time
 }
 
-pub unsafe fn dc_maybe_network(mut context: &dc_context_t) {
+pub unsafe fn dc_maybe_network(context: &dc_context_t) {
     {
         let &(ref lock, _) = &*context.smtp_state.clone();
         let mut state = lock.lock().unwrap();
@@ -1272,12 +1267,9 @@ pub unsafe fn dc_maybe_network(mut context: &dc_context_t) {
     dc_interrupt_sentbox_idle(context);
 }
 
-pub unsafe fn dc_job_action_exists(
-    mut context: &dc_context_t,
-    mut action: libc::c_int,
-) -> libc::c_int {
-    let mut job_exists: libc::c_int;
-    let mut stmt;
+pub unsafe fn dc_job_action_exists(context: &dc_context_t, action: libc::c_int) -> libc::c_int {
+    let job_exists: libc::c_int;
+    let stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -1331,7 +1323,7 @@ pub unsafe fn dc_job_send_msg(context: &dc_context_t, msg_id: uint32_t) -> libc:
             || (*mimefactory.msg).type_0 == 50i32
             || (*mimefactory.msg).type_0 == 60i32
         {
-            let mut pathNfilename = dc_param_get(
+            let pathNfilename = dc_param_get(
                 (*mimefactory.msg).param,
                 'f' as i32,
                 0 as *const libc::c_char,
diff --git a/src/dc_jobthread.rs b/src/dc_jobthread.rs
index 6aafd4295..74f21eefe 100644
--- a/src/dc_jobthread.rs
+++ b/src/dc_jobthread.rs
@@ -116,7 +116,7 @@ pub unsafe fn dc_jobthread_fetch(
     jobthread: &mut dc_jobthread_t,
     use_network: libc::c_int,
 ) {
-    let mut start;
+    let start;
 
     {
         let &(ref lock, _) = &*jobthread.state.clone();
diff --git a/src/dc_jsmn.rs b/src/dc_jsmn.rs
index 4db16f99c..1921ccbeb 100644
--- a/src/dc_jsmn.rs
+++ b/src/dc_jsmn.rs
@@ -82,10 +82,10 @@ pub unsafe fn jsmn_init(mut parser: *mut jsmn_parser) {
  */
 pub unsafe fn jsmn_parse(
     mut parser: *mut jsmn_parser,
-    mut js: *const libc::c_char,
-    mut len: size_t,
-    mut tokens: *mut jsmntok_t,
-    mut num_tokens: libc::c_uint,
+    js: *const libc::c_char,
+    len: size_t,
+    tokens: *mut jsmntok_t,
+    num_tokens: libc::c_uint,
 ) -> libc::c_int {
     let mut r: libc::c_int;
     let mut i: libc::c_int;
@@ -94,8 +94,8 @@ pub unsafe fn jsmn_parse(
     while (*parser).pos < len as libc::c_uint
         && *js.offset((*parser).pos as isize) as libc::c_int != '\u{0}' as i32
     {
-        let mut c: libc::c_char;
-        let mut type_0: jsmntype_t;
+        let c: libc::c_char;
+        let type_0: jsmntype_t;
         c = *js.offset((*parser).pos as isize);
         match c as libc::c_int {
             123 | 91 => {
@@ -231,13 +231,13 @@ pub unsafe fn jsmn_parse(
  */
 unsafe fn jsmn_parse_primitive(
     mut parser: *mut jsmn_parser,
-    mut js: *const libc::c_char,
-    mut len: size_t,
-    mut tokens: *mut jsmntok_t,
-    mut num_tokens: size_t,
+    js: *const libc::c_char,
+    len: size_t,
+    tokens: *mut jsmntok_t,
+    num_tokens: size_t,
 ) -> libc::c_int {
-    let mut token: *mut jsmntok_t;
-    let mut start: libc::c_int;
+    let token: *mut jsmntok_t;
+    let start: libc::c_int;
     start = (*parser).pos as libc::c_int;
     while (*parser).pos < len as libc::c_uint
         && *js.offset((*parser).pos as isize) as libc::c_int != '\u{0}' as i32
@@ -276,9 +276,9 @@ unsafe fn jsmn_parse_primitive(
  */
 unsafe fn jsmn_fill_token(
     mut token: *mut jsmntok_t,
-    mut type_0: jsmntype_t,
-    mut start: libc::c_int,
-    mut end: libc::c_int,
+    type_0: jsmntype_t,
+    start: libc::c_int,
+    end: libc::c_int,
 ) {
     (*token).type_0 = type_0;
     (*token).start = start;
@@ -313,8 +313,8 @@ THE SOFTWARE.
  */
 unsafe fn jsmn_alloc_token(
     mut parser: *mut jsmn_parser,
-    mut tokens: *mut jsmntok_t,
-    mut num_tokens: size_t,
+    tokens: *mut jsmntok_t,
+    num_tokens: size_t,
 ) -> *mut jsmntok_t {
     let mut tok: *mut jsmntok_t;
     if (*parser).toknext as size_t >= num_tokens {
@@ -335,18 +335,18 @@ unsafe fn jsmn_alloc_token(
  */
 unsafe fn jsmn_parse_string(
     mut parser: *mut jsmn_parser,
-    mut js: *const libc::c_char,
-    mut len: size_t,
-    mut tokens: *mut jsmntok_t,
-    mut num_tokens: size_t,
+    js: *const libc::c_char,
+    len: size_t,
+    tokens: *mut jsmntok_t,
+    num_tokens: size_t,
 ) -> libc::c_int {
-    let mut token: *mut jsmntok_t;
-    let mut start: libc::c_int = (*parser).pos as libc::c_int;
+    let token: *mut jsmntok_t;
+    let start: libc::c_int = (*parser).pos as libc::c_int;
     (*parser).pos = (*parser).pos.wrapping_add(1);
     while ((*parser).pos as size_t) < len
         && *js.offset((*parser).pos as isize) as libc::c_int != '\u{0}' as i32
     {
-        let mut c: libc::c_char = *js.offset((*parser).pos as isize);
+        let c: libc::c_char = *js.offset((*parser).pos as isize);
         if c as libc::c_int == '\"' as i32 {
             if tokens.is_null() {
                 return 0i32;
diff --git a/src/dc_key.rs b/src/dc_key.rs
index f7b0a6884..b6865a722 100644
--- a/src/dc_key.rs
+++ b/src/dc_key.rs
@@ -79,7 +79,7 @@ unsafe fn dc_key_empty(mut key: *mut dc_key_t) {
     (*key).type_0 = 0i32;
 }
 
-pub unsafe fn dc_wipe_secret_mem(mut buf: *mut libc::c_void, mut buf_bytes: size_t) {
+pub unsafe fn dc_wipe_secret_mem(buf: *mut libc::c_void, buf_bytes: size_t) {
     if buf.is_null() || buf_bytes <= 0 {
         return;
     }
@@ -89,9 +89,9 @@ pub unsafe fn dc_wipe_secret_mem(mut buf: *mut libc::c_void, mut buf_bytes: size
 // TODO should return bool /rtn
 pub unsafe fn dc_key_set_from_binary(
     mut key: *mut dc_key_t,
-    mut data: *const libc::c_void,
-    mut bytes: libc::c_int,
-    mut type_0: libc::c_int,
+    data: *const libc::c_void,
+    bytes: libc::c_int,
+    type_0: libc::c_int,
 ) -> libc::c_int {
     dc_key_empty(key);
     if key.is_null() || data == 0 as *mut libc::c_void || bytes <= 0i32 {
@@ -108,7 +108,7 @@ pub unsafe fn dc_key_set_from_binary(
     1
 }
 
-pub unsafe fn dc_key_set_from_key(mut key: *mut dc_key_t, mut o: *const dc_key_t) -> libc::c_int {
+pub unsafe fn dc_key_set_from_key(key: *mut dc_key_t, o: *const dc_key_t) -> libc::c_int {
     dc_key_empty(key);
     if key.is_null() || o.is_null() {
         return 0i32;
@@ -119,10 +119,10 @@ pub unsafe fn dc_key_set_from_key(mut key: *mut dc_key_t, mut o: *const dc_key_t
 
 // TODO should return bool /rtn
 pub unsafe extern "C" fn dc_key_set_from_stmt(
-    mut key: *mut dc_key_t,
-    mut stmt: *mut sqlite3_stmt,
-    mut index: libc::c_int,
-    mut type_0: libc::c_int,
+    key: *mut dc_key_t,
+    stmt: *mut sqlite3_stmt,
+    index: libc::c_int,
+    type_0: libc::c_int,
 ) -> libc::c_int {
     dc_key_empty(key);
     if key.is_null() || stmt.is_null() {
@@ -139,9 +139,9 @@ pub unsafe extern "C" fn dc_key_set_from_stmt(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_key_set_from_base64(
-    mut key: *mut dc_key_t,
-    mut base64: *const libc::c_char,
-    mut type_0: libc::c_int,
+    key: *mut dc_key_t,
+    base64: *const libc::c_char,
+    type_0: libc::c_int,
 ) -> libc::c_int {
     let mut indx: size_t = 0i32 as size_t;
     let mut result_len: size_t = 0i32 as size_t;
@@ -174,7 +174,7 @@ pub unsafe fn dc_key_set_from_base64(
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_key_equals(mut key: *const dc_key_t, mut o: *const dc_key_t) -> libc::c_int {
+pub unsafe fn dc_key_equals(key: *const dc_key_t, o: *const dc_key_t) -> libc::c_int {
     if key.is_null()
         || o.is_null()
         || (*key).binary.is_null()
@@ -371,9 +371,9 @@ pub fn dc_key_render_asc(key: *const dc_key_t, header: Option<(&str, &str)>) ->
 }
 
 pub unsafe fn dc_key_render_asc_to_file(
-    mut key: *const dc_key_t,
-    mut file: *const libc::c_char,
-    mut context: &dc_context_t,
+    key: *const dc_key_t,
+    file: *const libc::c_char,
+    context: &dc_context_t,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut file_content: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -404,9 +404,9 @@ pub unsafe fn dc_key_render_asc_to_file(
     success
 }
 
-pub unsafe fn dc_format_fingerprint(mut fingerprint: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_format_fingerprint(fingerprint: *const libc::c_char) -> *mut libc::c_char {
     let mut i: libc::c_int = 0i32;
-    let mut fingerprint_len: libc::c_int = strlen(fingerprint) as libc::c_int;
+    let fingerprint_len: libc::c_int = strlen(fingerprint) as libc::c_int;
     let mut ret: dc_strbuilder_t = dc_strbuilder_t {
         buf: 0 as *mut libc::c_char,
         allocated: 0,
@@ -433,7 +433,7 @@ pub unsafe fn dc_format_fingerprint(mut fingerprint: *const libc::c_char) -> *mu
     ret.buf
 }
 
-pub unsafe fn dc_normalize_fingerprint(mut in_0: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_normalize_fingerprint(in_0: *const libc::c_char) -> *mut libc::c_char {
     if in_0.is_null() {
         return 0 as *mut libc::c_char;
     }
@@ -488,8 +488,8 @@ pub unsafe fn dc_key_get_formatted_fingerprint(
     context: &dc_context_t,
     key: *const dc_key_t,
 ) -> *mut libc::c_char {
-    let mut rawhex: *mut libc::c_char = dc_key_get_fingerprint(context, key);
-    let mut formatted: *mut libc::c_char = dc_format_fingerprint(rawhex);
+    let rawhex: *mut libc::c_char = dc_key_get_fingerprint(context, key);
+    let formatted: *mut libc::c_char = dc_format_fingerprint(rawhex);
     free(rawhex as *mut libc::c_void);
 
     formatted
diff --git a/src/dc_keyring.rs b/src/dc_keyring.rs
index 81bc280ab..b22b24810 100644
--- a/src/dc_keyring.rs
+++ b/src/dc_keyring.rs
@@ -13,7 +13,7 @@ pub struct dc_keyring_t {
 }
 
 pub unsafe fn dc_keyring_new() -> *mut dc_keyring_t {
-    let mut keyring: *mut dc_keyring_t;
+    let keyring: *mut dc_keyring_t;
     keyring = calloc(1, ::std::mem::size_of::<dc_keyring_t>()) as *mut dc_keyring_t;
     if keyring.is_null() {
         exit(42i32);
@@ -22,7 +22,7 @@ pub unsafe fn dc_keyring_new() -> *mut dc_keyring_t {
     keyring
 }
 
-pub unsafe fn dc_keyring_unref(mut keyring: *mut dc_keyring_t) {
+pub unsafe fn dc_keyring_unref(keyring: *mut dc_keyring_t) {
     if keyring.is_null() {
         return;
     }
@@ -36,12 +36,12 @@ pub unsafe fn dc_keyring_unref(mut keyring: *mut dc_keyring_t) {
 }
 
 /* the reference counter of the key is increased by one */
-pub unsafe fn dc_keyring_add(mut keyring: *mut dc_keyring_t, mut to_add: *mut dc_key_t) {
+pub unsafe fn dc_keyring_add(mut keyring: *mut dc_keyring_t, to_add: *mut dc_key_t) {
     if keyring.is_null() || to_add.is_null() {
         return;
     }
     if (*keyring).count == (*keyring).allocated {
-        let mut newsize = (*keyring).allocated * 2 + 10;
+        let newsize = (*keyring).allocated * 2 + 10;
         (*keyring).keys = realloc(
             (*keyring).keys as *mut libc::c_void,
             (newsize as size_t).wrapping_mul(::std::mem::size_of::<*mut dc_key_t>()),
@@ -67,7 +67,7 @@ pub unsafe fn dc_keyring_load_self_private_for_decrypting(
     if keyring.is_null() || self_addr.is_null() {
         return 0i32;
     }
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         context,
         sql,
         b"SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;\x00" as *const u8
@@ -75,7 +75,7 @@ pub unsafe fn dc_keyring_load_self_private_for_decrypting(
     );
     sqlite3_bind_text(stmt, 1i32, self_addr, -1i32, None);
     while sqlite3_step(stmt) == 100i32 {
-        let mut key: *mut dc_key_t = dc_key_new();
+        let key: *mut dc_key_t = dc_key_new();
         if 0 != dc_key_set_from_stmt(key, stmt, 0i32, 1i32) {
             dc_keyring_add(keyring, key);
         }
diff --git a/src/dc_location.rs b/src/dc_location.rs
index 8e5d820a4..0e7a0589e 100644
--- a/src/dc_location.rs
+++ b/src/dc_location.rs
@@ -40,15 +40,15 @@ pub struct dc_kml_t {
 
 // location streaming
 pub unsafe fn dc_send_locations_to_chat(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut seconds: libc::c_int,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    seconds: libc::c_int,
 ) {
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut now: time_t = time(0 as *mut time_t);
+    let now: time_t = time(0 as *mut time_t);
     let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
     let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut is_sending_locations_before: libc::c_int;
+    let is_sending_locations_before: libc::c_int;
     if !(seconds < 0i32 || chat_id <= 9i32 as libc::c_uint) {
         is_sending_locations_before = dc_is_sending_locations_to_chat(context, chat_id);
         stmt =
@@ -123,18 +123,18 @@ pub unsafe fn dc_send_locations_to_chat(
 /*******************************************************************************
  * job to send locations out to all chats that want them
  ******************************************************************************/
-unsafe fn schedule_MAYBE_SEND_LOCATIONS(mut context: &dc_context_t, mut flags: libc::c_int) {
+unsafe fn schedule_MAYBE_SEND_LOCATIONS(context: &dc_context_t, flags: libc::c_int) {
     if 0 != flags & 0x1i32 || 0 == dc_job_action_exists(context, 5005i32) {
         dc_job_add(context, 5005i32, 0i32, 0 as *const libc::c_char, 60i32);
     };
 }
 
 pub unsafe extern "C" fn dc_is_sending_locations_to_chat(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
 ) -> libc::c_int {
     let mut is_sending_locations: libc::c_int = 0i32;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
 
     stmt = dc_sqlite3_prepare(
         context,
@@ -163,10 +163,10 @@ pub unsafe extern "C" fn dc_is_sending_locations_to_chat(
 }
 
 pub unsafe fn dc_set_location(
-    mut context: &dc_context_t,
-    mut latitude: libc::c_double,
-    mut longitude: libc::c_double,
-    mut accuracy: libc::c_double,
+    context: &dc_context_t,
+    latitude: libc::c_double,
+    longitude: libc::c_double,
+    accuracy: libc::c_double,
 ) -> libc::c_int {
     let mut stmt_chats: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -182,7 +182,7 @@ pub unsafe fn dc_set_location(
         );
         sqlite3_bind_int64(stmt_chats, 1i32, time(0 as *mut time_t) as sqlite3_int64);
         while sqlite3_step(stmt_chats) == 100i32 {
-            let mut chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
+            let chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
             stmt_insert =
                 dc_sqlite3_prepare(
                     context,
@@ -215,14 +215,14 @@ pub unsafe fn dc_set_location(
 }
 
 pub unsafe fn dc_get_locations(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut contact_id: uint32_t,
-    mut timestamp_from: time_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    contact_id: uint32_t,
+    timestamp_from: time_t,
     mut timestamp_to: time_t,
 ) -> *mut dc_array_t {
-    let mut ret: *mut dc_array_t = dc_array_new_typed(1i32, 500i32 as size_t);
-    let mut stmt: *mut sqlite3_stmt;
+    let ret: *mut dc_array_t = dc_array_new_typed(1i32, 500i32 as size_t);
+    let stmt: *mut sqlite3_stmt;
 
     if timestamp_to == 0i32 as libc::c_long {
         timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long
@@ -277,8 +277,7 @@ pub unsafe fn dc_get_locations(
         (*loc).chat_id = sqlite3_column_int(stmt, 8i32) as uint32_t;
 
         if 0 != (*loc).msg_id {
-            let mut txt: *const libc::c_char =
-                sqlite3_column_text(stmt, 9i32) as *const libc::c_char;
+            let txt: *const libc::c_char = sqlite3_column_text(stmt, 9i32) as *const libc::c_char;
             if 0 != is_marker(txt) {
                 (*loc).marker = strdup(txt)
             }
@@ -292,9 +291,9 @@ pub unsafe fn dc_get_locations(
 }
 
 // TODO should be bool /rtn
-unsafe fn is_marker(mut txt: *const libc::c_char) -> libc::c_int {
+unsafe fn is_marker(txt: *const libc::c_char) -> libc::c_int {
     if !txt.is_null() {
-        let mut len: libc::c_int = dc_utf8_strlen(txt) as libc::c_int;
+        let len: libc::c_int = dc_utf8_strlen(txt) as libc::c_int;
         if len == 1i32 && *txt.offset(0isize) as libc::c_int != ' ' as i32 {
             return 1i32;
         }
@@ -303,8 +302,8 @@ unsafe fn is_marker(mut txt: *const libc::c_char) -> libc::c_int {
     0
 }
 
-pub unsafe fn dc_delete_all_locations(mut context: &dc_context_t) {
-    let mut stmt: *mut sqlite3_stmt;
+pub unsafe fn dc_delete_all_locations(context: &dc_context_t) {
+    let stmt: *mut sqlite3_stmt;
 
     stmt = dc_sqlite3_prepare(
         context,
@@ -323,17 +322,17 @@ pub unsafe fn dc_delete_all_locations(mut context: &dc_context_t) {
 }
 
 pub unsafe fn dc_get_location_kml(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut last_added_location_id: *mut uint32_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    last_added_location_id: *mut uint32_t,
 ) -> *mut libc::c_char {
     let mut success: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt;
-    let mut self_addr: *mut libc::c_char;
-    let mut now: time_t = time(0 as *mut time_t);
-    let mut locations_send_begin: time_t;
-    let mut locations_send_until: time_t;
-    let mut locations_last_sent: time_t;
+    let self_addr: *mut libc::c_char;
+    let now: time_t = time(0 as *mut time_t);
+    let locations_send_begin: time_t;
+    let locations_send_until: time_t;
+    let locations_last_sent: time_t;
     let mut location_count: libc::c_int = 0i32;
     let mut ret: dc_strbuilder_t = dc_strbuilder_t {
         buf: 0 as *mut libc::c_char,
@@ -385,11 +384,11 @@ pub unsafe fn dc_get_location_kml(
             sqlite3_bind_int64(stmt, 3i32, locations_last_sent as sqlite3_int64);
             sqlite3_bind_int(stmt, 4i32, 1i32);
             while sqlite3_step(stmt) == 100i32 {
-                let mut location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
-                let mut latitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 1i32));
-                let mut longitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 2i32));
-                let mut accuracy: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 3i32));
-                let mut timestamp: *mut libc::c_char =
+                let location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
+                let latitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 1i32));
+                let longitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 2i32));
+                let accuracy: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 3i32));
+                let timestamp: *mut libc::c_char =
                     get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as time_t);
                 dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
                                        b"<Placemark><Timestamp><when>%s</when></Timestamp><Point><coordinates accuracy=\"%s\">%s,%s</coordinates></Point></Placemark>\n\x00"
@@ -498,7 +497,7 @@ pub unsafe fn dc_set_kml_sent_timestamp(
     chat_id: uint32_t,
     timestamp: time_t,
 ) {
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -512,11 +511,11 @@ pub unsafe fn dc_set_kml_sent_timestamp(
 }
 
 pub unsafe fn dc_set_msg_location_id(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-    mut location_id: uint32_t,
+    context: &dc_context_t,
+    msg_id: uint32_t,
+    location_id: uint32_t,
 ) {
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -529,10 +528,10 @@ pub unsafe fn dc_set_msg_location_id(
 }
 
 pub unsafe fn dc_save_locations(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut contact_id: uint32_t,
-    mut locations: *const dc_array_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    contact_id: uint32_t,
+    locations: *const dc_array_t,
     independent: libc::c_int,
 ) -> uint32_t {
     let mut stmt_test: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -555,7 +554,7 @@ pub unsafe fn dc_save_locations(
         );
         let mut i = 0;
         while i < dc_array_get_cnt(locations) {
-            let mut location: *mut dc_location_t =
+            let location: *mut dc_location_t =
                 dc_array_get_ptr(locations, i as size_t) as *mut dc_location_t;
             sqlite3_reset(stmt_test);
             sqlite3_bind_int64(stmt_test, 1i32, (*location).timestamp as sqlite3_int64);
@@ -593,9 +592,9 @@ pub unsafe fn dc_save_locations(
 }
 
 pub unsafe fn dc_kml_parse(
-    mut context: &dc_context_t,
-    mut content: *const libc::c_char,
-    mut content_bytes: size_t,
+    context: &dc_context_t,
+    content: *const libc::c_char,
+    content_bytes: size_t,
 ) -> *mut dc_kml_t {
     let mut kml: *mut dc_kml_t = calloc(1, ::std::mem::size_of::<dc_kml_t>()) as *mut dc_kml_t;
     let mut content_nullterminated: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -696,8 +695,8 @@ unsafe fn kml_text_cb(userdata: *mut libc::c_void, text: *const libc::c_char, _l
         } else if 0 != (*kml).tag & 0x10i32 {
             let mut comma: *mut libc::c_char = strchr(val, ',' as i32);
             if !comma.is_null() {
-                let mut longitude: *mut libc::c_char = val;
-                let mut latitude: *mut libc::c_char = comma.offset(1isize);
+                let longitude: *mut libc::c_char = val;
+                let latitude: *mut libc::c_char = comma.offset(1isize);
                 *comma = 0i32 as libc::c_char;
                 comma = strchr(latitude, ',' as i32);
                 if !comma.is_null() {
@@ -711,7 +710,7 @@ unsafe fn kml_text_cb(userdata: *mut libc::c_void, text: *const libc::c_char, _l
     };
 }
 
-unsafe fn kml_endtag_cb(mut userdata: *mut libc::c_void, mut tag: *const libc::c_char) {
+unsafe fn kml_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char) {
     let mut kml: *mut dc_kml_t = userdata as *mut dc_kml_t;
     if strcmp(tag, b"placemark\x00" as *const u8 as *const libc::c_char) == 0i32 {
         if 0 != (*kml).tag & 0x1i32
@@ -719,7 +718,7 @@ unsafe fn kml_endtag_cb(mut userdata: *mut libc::c_void, mut tag: *const libc::c
             && 0. != (*kml).curr.latitude
             && 0. != (*kml).curr.longitude
         {
-            let mut location: *mut dc_location_t =
+            let location: *mut dc_location_t =
                 calloc(1, ::std::mem::size_of::<dc_location_t>()) as *mut dc_location_t;
             *location = (*kml).curr;
             dc_array_add_ptr((*kml).locations, location as *mut libc::c_void);
@@ -732,13 +731,13 @@ unsafe fn kml_endtag_cb(mut userdata: *mut libc::c_void, mut tag: *const libc::c
  * parse kml-files
  ******************************************************************************/
 unsafe fn kml_starttag_cb(
-    mut userdata: *mut libc::c_void,
-    mut tag: *const libc::c_char,
-    mut attr: *mut *mut libc::c_char,
+    userdata: *mut libc::c_void,
+    tag: *const libc::c_char,
+    attr: *mut *mut libc::c_char,
 ) {
     let mut kml: *mut dc_kml_t = userdata as *mut dc_kml_t;
     if strcmp(tag, b"document\x00" as *const u8 as *const libc::c_char) == 0i32 {
-        let mut addr: *const libc::c_char =
+        let addr: *const libc::c_char =
             dc_attr_find(attr, b"addr\x00" as *const u8 as *const libc::c_char);
         if !addr.is_null() {
             (*kml).addr = dc_strdup(addr)
@@ -765,7 +764,7 @@ unsafe fn kml_starttag_cb(
         && 0 != (*kml).tag & 0x8i32
     {
         (*kml).tag = 0x1i32 | 0x8i32 | 0x10i32;
-        let mut accuracy: *const libc::c_char =
+        let accuracy: *const libc::c_char =
             dc_attr_find(attr, b"accuracy\x00" as *const u8 as *const libc::c_char);
         if !accuracy.is_null() {
             (*kml).curr.accuracy = dc_atof(accuracy)
@@ -773,7 +772,7 @@ unsafe fn kml_starttag_cb(
     };
 }
 
-pub unsafe fn dc_kml_unref(mut kml: *mut dc_kml_t) {
+pub unsafe fn dc_kml_unref(kml: *mut dc_kml_t) {
     if kml.is_null() {
         return;
     }
@@ -783,9 +782,9 @@ pub unsafe fn dc_kml_unref(mut kml: *mut dc_kml_t) {
 }
 
 pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job: *mut dc_job_t) {
-    let mut stmt_chats: *mut sqlite3_stmt;
+    let stmt_chats: *mut sqlite3_stmt;
     let mut stmt_locations: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut now: time_t = time(0 as *mut time_t);
+    let now: time_t = time(0 as *mut time_t);
     let mut continue_streaming: libc::c_int = 1i32;
     dc_log_info(
         context,
@@ -802,9 +801,9 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
     );
     sqlite3_bind_int64(stmt_chats, 1i32, now as sqlite3_int64);
     while sqlite3_step(stmt_chats) == 100i32 {
-        let mut chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
-        let mut locations_send_begin: time_t = sqlite3_column_int64(stmt_chats, 1i32) as time_t;
-        let mut locations_last_sent: time_t = sqlite3_column_int64(stmt_chats, 2i32) as time_t;
+        let chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
+        let locations_send_begin: time_t = sqlite3_column_int64(stmt_chats, 1i32) as time_t;
+        let locations_last_sent: time_t = sqlite3_column_int64(stmt_chats, 2i32) as time_t;
         continue_streaming = 1i32;
         // be a bit tolerant as the timer may not align exactly with time(NULL)
         if now - locations_last_sent < (60i32 - 3i32) as libc::c_long {
@@ -855,16 +854,13 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
     sqlite3_finalize(stmt_locations);
 }
 
-pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
-    mut context: &dc_context_t,
-    mut job: &mut dc_job_t,
-) {
+pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context: &dc_context_t, job: &mut dc_job_t) {
     // this function is called when location-streaming _might_ have ended for a chat.
     // the function checks, if location-streaming is really ended;
     // if so, a device-message is added if not yet done.
-    let mut chat_id: uint32_t = (*job).foreign_id;
-    let mut locations_send_begin: time_t;
-    let mut locations_send_until: time_t;
+    let chat_id: uint32_t = (*job).foreign_id;
+    let locations_send_begin: time_t;
+    let locations_send_until: time_t;
     let mut stmt;
     let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
     stmt = dc_sqlite3_prepare(
diff --git a/src/dc_log.rs b/src/dc_log.rs
index ee6149aeb..5b20ff888 100644
--- a/src/dc_log.rs
+++ b/src/dc_log.rs
@@ -5,11 +5,11 @@ use crate::types::*;
 use crate::x::*;
 
 pub unsafe extern "C" fn dc_log_event(
-    mut context: &dc_context_t,
-    mut event_code: Event,
-    mut data1: libc::c_int,
-    mut msg: *const libc::c_char,
-    mut va: ...
+    context: &dc_context_t,
+    event_code: Event,
+    data1: libc::c_int,
+    msg: *const libc::c_char,
+    va: ...
 ) {
     log_vprintf(context, event_code, data1, msg, va);
 }
@@ -22,13 +22,13 @@ usually not reported using dc_log_error() - its up to the caller to
 decide, what should be reported or done.  However, these "Normal" errors
 are usually logged by dc_log_warning(). */
 unsafe fn log_vprintf(
-    mut context: &dc_context_t,
-    mut event: Event,
-    mut data1: libc::c_int,
-    mut msg_format: *const libc::c_char,
-    mut va_0: ::std::ffi::VaList,
+    context: &dc_context_t,
+    event: Event,
+    data1: libc::c_int,
+    msg_format: *const libc::c_char,
+    va_0: ::std::ffi::VaList,
 ) {
-    let mut msg: *mut libc::c_char;
+    let msg: *mut libc::c_char;
     if !msg_format.is_null() {
         let mut tempbuf: [libc::c_char; 1025] = [0; 1025];
         vsnprintf(
@@ -49,11 +49,11 @@ unsafe fn log_vprintf(
 }
 
 pub unsafe extern "C" fn dc_log_event_seq(
-    mut context: &dc_context_t,
-    mut event_code: Event,
-    mut sequence_start: *mut libc::c_int,
-    mut msg: *const libc::c_char,
-    mut va_0: ...
+    context: &dc_context_t,
+    event_code: Event,
+    sequence_start: *mut libc::c_int,
+    msg: *const libc::c_char,
+    va_0: ...
 ) {
     if sequence_start.is_null() {
         return;
@@ -63,28 +63,28 @@ pub unsafe extern "C" fn dc_log_event_seq(
 }
 
 pub unsafe extern "C" fn dc_log_error(
-    mut context: &dc_context_t,
-    mut data1: libc::c_int,
-    mut msg: *const libc::c_char,
-    mut va_1: ...
+    context: &dc_context_t,
+    data1: libc::c_int,
+    msg: *const libc::c_char,
+    va_1: ...
 ) {
     log_vprintf(context, Event::ERROR, data1, msg, va_1);
 }
 
 pub unsafe extern "C" fn dc_log_warning(
-    mut context: &dc_context_t,
-    mut data1: libc::c_int,
-    mut msg: *const libc::c_char,
-    mut va_2: ...
+    context: &dc_context_t,
+    data1: libc::c_int,
+    msg: *const libc::c_char,
+    va_2: ...
 ) {
     log_vprintf(context, Event::WARNING, data1, msg, va_2);
 }
 
 pub unsafe extern "C" fn dc_log_info(
-    mut context: &dc_context_t,
-    mut data1: libc::c_int,
-    mut msg: *const libc::c_char,
-    mut va_3: ...
+    context: &dc_context_t,
+    data1: libc::c_int,
+    msg: *const libc::c_char,
+    va_3: ...
 ) {
     log_vprintf(context, Event::INFO, data1, msg, va_3);
 }
diff --git a/src/dc_loginparam.rs b/src/dc_loginparam.rs
index b9cc29a87..b30a64175 100644
--- a/src/dc_loginparam.rs
+++ b/src/dc_loginparam.rs
@@ -21,7 +21,7 @@ pub struct dc_loginparam_t {
 }
 
 pub unsafe fn dc_loginparam_new() -> *mut dc_loginparam_t {
-    let mut loginparam: *mut dc_loginparam_t;
+    let loginparam: *mut dc_loginparam_t;
     loginparam = calloc(1, ::std::mem::size_of::<dc_loginparam_t>()) as *mut dc_loginparam_t;
     if loginparam.is_null() {
         exit(22i32);
@@ -30,7 +30,7 @@ pub unsafe fn dc_loginparam_new() -> *mut dc_loginparam_t {
     loginparam
 }
 
-pub unsafe fn dc_loginparam_unref(mut loginparam: *mut dc_loginparam_t) {
+pub unsafe fn dc_loginparam_unref(loginparam: *mut dc_loginparam_t) {
     if loginparam.is_null() {
         return;
     }
@@ -223,16 +223,14 @@ pub unsafe fn dc_loginparam_write(
     sqlite3_free(key as *mut libc::c_void);
 }
 
-pub unsafe fn dc_loginparam_get_readable(
-    mut loginparam: *const dc_loginparam_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 pw: *const libc::c_char = b"***\x00" as *const u8 as *const libc::c_char;
+pub unsafe fn dc_loginparam_get_readable(loginparam: *const dc_loginparam_t) -> *mut libc::c_char {
+    let unset: *const libc::c_char = b"0\x00" as *const u8 as *const libc::c_char;
+    let pw: *const libc::c_char = b"***\x00" as *const u8 as *const libc::c_char;
     if loginparam.is_null() {
         return dc_strdup(0 as *const libc::c_char);
     }
-    let mut flags_readable: *mut libc::c_char = get_readable_flags((*loginparam).server_flags);
-    let mut ret: *mut libc::c_char = dc_mprintf(
+    let flags_readable: *mut libc::c_char = get_readable_flags((*loginparam).server_flags);
+    let ret: *mut libc::c_char = dc_mprintf(
         b"%s %s:%s:%s:%i %s:%s:%s:%i %s\x00" as *const u8 as *const libc::c_char,
         if !(*loginparam).addr.is_null() {
             (*loginparam).addr
@@ -278,7 +276,7 @@ pub unsafe fn dc_loginparam_get_readable(
     ret
 }
 
-unsafe fn get_readable_flags(mut flags: libc::c_int) -> *mut libc::c_char {
+unsafe fn get_readable_flags(flags: libc::c_int) -> *mut libc::c_char {
     let mut strbuilder: dc_strbuilder_t = dc_strbuilder_t {
         buf: 0 as *mut libc::c_char,
         allocated: 0,
@@ -347,7 +345,7 @@ unsafe fn get_readable_flags(mut flags: libc::c_int) -> *mut libc::c_char {
                 flag_added = 1i32
             }
             if 0 == flag_added {
-                let mut temp: *mut libc::c_char = dc_mprintf(
+                let temp: *mut libc::c_char = dc_mprintf(
                     b"0x%x \x00" as *const u8 as *const libc::c_char,
                     1i32 << bit,
                 );
diff --git a/src/dc_lot.rs b/src/dc_lot.rs
index e548d47b4..47b74de3a 100644
--- a/src/dc_lot.rs
+++ b/src/dc_lot.rs
@@ -74,7 +74,7 @@ pub unsafe fn dc_lot_unref(mut set: *mut dc_lot_t) {
     free(set as *mut libc::c_void);
 }
 
-pub unsafe fn dc_lot_get_text1(mut lot: *const dc_lot_t) -> *mut libc::c_char {
+pub unsafe fn dc_lot_get_text1(lot: *const dc_lot_t) -> *mut libc::c_char {
     if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
         return 0 as *mut libc::c_char;
     }
@@ -82,7 +82,7 @@ pub unsafe fn dc_lot_get_text1(mut lot: *const dc_lot_t) -> *mut libc::c_char {
     dc_strdup_keep_null((*lot).text1)
 }
 
-pub unsafe fn dc_lot_get_text2(mut lot: *const dc_lot_t) -> *mut libc::c_char {
+pub unsafe fn dc_lot_get_text2(lot: *const dc_lot_t) -> *mut libc::c_char {
     if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
         return 0 as *mut libc::c_char;
     }
@@ -90,7 +90,7 @@ pub unsafe fn dc_lot_get_text2(mut lot: *const dc_lot_t) -> *mut libc::c_char {
     dc_strdup_keep_null((*lot).text2)
 }
 
-pub unsafe fn dc_lot_get_text1_meaning(mut lot: *const dc_lot_t) -> libc::c_int {
+pub unsafe fn dc_lot_get_text1_meaning(lot: *const dc_lot_t) -> libc::c_int {
     if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
         return 0i32;
     }
@@ -98,7 +98,7 @@ pub unsafe fn dc_lot_get_text1_meaning(mut lot: *const dc_lot_t) -> libc::c_int
     (*lot).text1_meaning
 }
 
-pub unsafe fn dc_lot_get_state(mut lot: *const dc_lot_t) -> libc::c_int {
+pub unsafe fn dc_lot_get_state(lot: *const dc_lot_t) -> libc::c_int {
     if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
         return 0i32;
     }
@@ -106,7 +106,7 @@ pub unsafe fn dc_lot_get_state(mut lot: *const dc_lot_t) -> libc::c_int {
     (*lot).state
 }
 
-pub unsafe fn dc_lot_get_id(mut lot: *const dc_lot_t) -> uint32_t {
+pub unsafe fn dc_lot_get_id(lot: *const dc_lot_t) -> uint32_t {
     if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
         return 0i32 as uint32_t;
     }
@@ -114,7 +114,7 @@ pub unsafe fn dc_lot_get_id(mut lot: *const dc_lot_t) -> uint32_t {
     (*lot).id
 }
 
-pub unsafe fn dc_lot_get_timestamp(mut lot: *const dc_lot_t) -> time_t {
+pub unsafe fn dc_lot_get_timestamp(lot: *const dc_lot_t) -> time_t {
     if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint {
         return 0i32 as time_t;
     }
@@ -126,10 +126,10 @@ pub unsafe fn dc_lot_get_timestamp(mut lot: *const dc_lot_t) -> time_t {
 /* in practice, the user additionally cuts the string himself pixel-accurate */
 pub unsafe fn dc_lot_fill(
     mut lot: *mut dc_lot_t,
-    mut msg: *const dc_msg_t,
-    mut chat: *const dc_chat_t,
-    mut contact: *const dc_contact_t,
-    mut context: &dc_context_t,
+    msg: *const dc_msg_t,
+    chat: *const dc_chat_t,
+    contact: *const dc_contact_t,
+    context: &dc_context_t,
 ) {
     if lot.is_null() || (*lot).magic != 0x107107i32 as libc::c_uint || msg.is_null() {
         return;
diff --git a/src/dc_mimefactory.rs b/src/dc_mimefactory.rs
index 4b2355713..836d9a786 100644
--- a/src/dc_mimefactory.rs
+++ b/src/dc_mimefactory.rs
@@ -112,7 +112,7 @@ pub unsafe fn dc_mimefactory_empty(mut factory: *mut dc_mimefactory_t) {
 
 pub unsafe fn dc_mimefactory_load_msg(
     mut factory: *mut dc_mimefactory_t,
-    mut msg_id: uint32_t,
+    msg_id: uint32_t,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -149,9 +149,9 @@ pub unsafe fn dc_mimefactory_load_msg(
                             *const libc::c_char);
                 sqlite3_bind_int(stmt, 1i32, (*(*factory).msg).chat_id as libc::c_int);
                 while sqlite3_step(stmt) == 100i32 {
-                    let mut authname: *const libc::c_char =
+                    let authname: *const libc::c_char =
                         sqlite3_column_text(stmt, 0i32) as *const libc::c_char;
-                    let mut addr: *const libc::c_char =
+                    let addr: *const libc::c_char =
                         sqlite3_column_text(stmt, 1i32) as *const libc::c_char;
                     if clist_search_string_nocase((*factory).recipients_addr, addr) == 0i32 {
                         clist_insert_after(
@@ -172,15 +172,15 @@ pub unsafe fn dc_mimefactory_load_msg(
                     }
                 }
                 sqlite3_finalize(stmt);
-                let mut command: libc::c_int =
+                let command: libc::c_int =
                     dc_param_get_int((*(*factory).msg).param, 'S' as i32, 0i32);
                 if command == 5i32 {
-                    let mut email_to_remove: *mut libc::c_char = dc_param_get(
+                    let email_to_remove: *mut libc::c_char = dc_param_get(
                         (*(*factory).msg).param,
                         'E' as i32,
                         0 as *const libc::c_char,
                     );
-                    let mut self_addr: *mut libc::c_char = dc_sqlite3_get_config(
+                    let self_addr: *mut libc::c_char = dc_sqlite3_get_config(
                         context,
                         &context.sql.clone().read().unwrap(),
                         b"configured_addr\x00" as *const u8 as *const libc::c_char,
@@ -271,7 +271,7 @@ unsafe fn load_from(mut factory: *mut dc_mimefactory_t) {
 
 pub unsafe fn dc_mimefactory_load_mdn(
     mut factory: *mut dc_mimefactory_t,
-    mut msg_id: uint32_t,
+    msg_id: uint32_t,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
@@ -335,9 +335,9 @@ pub unsafe fn dc_mimefactory_load_mdn(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc::c_int {
-    let mut subject: *mut mailimf_subject;
+    let subject: *mut mailimf_subject;
     let mut current_block: u64;
-    let mut imf_fields: *mut mailimf_fields;
+    let imf_fields: *mut mailimf_fields;
     let mut message: *mut mailmime = 0 as *mut mailmime;
     let mut message_text: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut message_text2: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -374,7 +374,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
             b"Invalid use of mimefactory-object.\x00" as *const u8 as *const libc::c_char,
         );
     } else {
-        let mut from: *mut mailimf_mailbox_list = mailimf_mailbox_list_new_empty();
+        let from: *mut mailimf_mailbox_list = mailimf_mailbox_list_new_empty();
         mailimf_mailbox_list_add(
             from,
             mailimf_mailbox_new(
@@ -397,12 +397,12 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
             iter1 = (*(*factory).recipients_names).first;
             iter2 = (*(*factory).recipients_addr).first;
             while !iter1.is_null() && !iter2.is_null() {
-                let mut name: *const libc::c_char = (if !iter1.is_null() {
+                let name: *const libc::c_char = (if !iter1.is_null() {
                     (*iter1).data
                 } else {
                     0 as *mut libc::c_void
                 }) as *const libc::c_char;
-                let mut addr: *const libc::c_char = (if !iter2.is_null() {
+                let addr: *const libc::c_char = (if !iter2.is_null() {
                     (*iter2).data
                 } else {
                     0 as *mut libc::c_void
@@ -508,8 +508,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
         if (*factory).loaded as libc::c_uint == DC_MF_MSG_LOADED as libc::c_int as libc::c_uint {
             /* Render a normal message
              *********************************************************************/
-            let mut chat: *mut dc_chat_t = (*factory).chat;
-            let mut msg: *mut dc_msg_t = (*factory).msg;
+            let chat: *mut dc_chat_t = (*factory).chat;
+            let msg: *mut dc_msg_t = (*factory).msg;
             let mut meta_part: *mut mailmime = 0 as *mut mailmime;
             let mut placeholdertext: *mut libc::c_char = 0 as *mut libc::c_char;
             if (*chat).type_0 == 130i32 {
@@ -536,7 +536,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                 do_gossip = 1i32
             }
             /* build header etc. */
-            let mut command: libc::c_int = dc_param_get_int((*msg).param, 'S' as i32, 0i32);
+            let command: libc::c_int = dc_param_get_int((*msg).param, 'S' as i32, 0i32);
             if (*chat).type_0 == 120i32 || (*chat).type_0 == 130i32 {
                 mailimf_fields_add(
                     imf_fields,
@@ -553,7 +553,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                     ),
                 );
                 if command == 5i32 {
-                    let mut email_to_remove: *mut libc::c_char =
+                    let email_to_remove: *mut libc::c_char =
                         dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char);
                     if !email_to_remove.is_null() {
                         mailimf_fields_add(
@@ -569,7 +569,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                     }
                 } else if command == 4i32 {
                     do_gossip = 1i32;
-                    let mut email_to_add: *mut libc::c_char =
+                    let email_to_add: *mut libc::c_char =
                         dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char);
                     if !email_to_add.is_null() {
                         mailimf_fields_add(
@@ -649,7 +649,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                 placeholdertext = dc_stock_str((*factory).context, 43i32)
             }
             if command == 7i32 {
-                let mut step: *mut libc::c_char =
+                let step: *mut libc::c_char =
                     dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char);
                 if !step.is_null() {
                     dc_log_info(
@@ -666,7 +666,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                             step,
                         ),
                     );
-                    let mut param2: *mut libc::c_char =
+                    let param2: *mut libc::c_char =
                         dc_param_get((*msg).param, 'F' as i32, 0 as *const libc::c_char);
                     if !param2.is_null() {
                         mailimf_fields_add(
@@ -695,7 +695,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                             ),
                         );
                     }
-                    let mut fingerprint: *mut libc::c_char =
+                    let fingerprint: *mut libc::c_char =
                         dc_param_get((*msg).param, 'G' as i32, 0 as *const libc::c_char);
                     if !fingerprint.is_null() {
                         mailimf_fields_add(
@@ -709,7 +709,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                             ),
                         );
                     }
-                    let mut grpid: *mut libc::c_char =
+                    let grpid: *mut libc::c_char =
                         dc_param_get((*msg).param, 'H' as i32, 0 as *const libc::c_char);
                     if !grpid.is_null() {
                         mailimf_fields_add(
@@ -755,7 +755,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                         ),
                     );
                 }
-                let mut duration_ms: libc::c_int = dc_param_get_int((*msg).param, 'd' as i32, 0i32);
+                let duration_ms: libc::c_int = dc_param_get_int((*msg).param, 'd' as i32, 0i32);
                 if duration_ms > 0i32 {
                     mailimf_fields_add(
                         imf_fields,
@@ -783,7 +783,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
             } else if !(*msg).text.is_null() && 0 != *(*msg).text.offset(0isize) as libc::c_int {
                 final_text = (*msg).text
             }
-            let mut footer: *mut libc::c_char = (*factory).selfstatus;
+            let footer: *mut libc::c_char = (*factory).selfstatus;
             message_text = dc_mprintf(
                 b"%s%s%s%s%s\x00" as *const u8 as *const libc::c_char,
                 if !fwdhint.is_null() {
@@ -815,7 +815,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                     b"\x00" as *const u8 as *const libc::c_char
                 },
             );
-            let mut text_part: *mut mailmime = build_body_text(message_text);
+            let text_part: *mut mailmime = build_body_text(message_text);
             mailmime_smart_add_part(message, text_part);
             parts += 1;
             free(fwdhint as *mut libc::c_void);
@@ -829,7 +829,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                 || (*msg).type_0 == 60i32
             {
                 if 0 == is_file_size_okay(msg) {
-                    let mut error: *mut libc::c_char = dc_mprintf(
+                    let error: *mut libc::c_char = dc_mprintf(
                         b"Message exceeds the recommended %i MB.\x00" as *const u8
                             as *const libc::c_char,
                         24i32 * 1024i32 * 1024i32 / 4i32 * 3i32 / 1000i32 / 1000i32,
@@ -838,7 +838,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                     free(error as *mut libc::c_void);
                     current_block = 11328123142868406523;
                 } else {
-                    let mut file_part: *mut mailmime =
+                    let file_part: *mut mailmime =
                         build_body_file(msg, 0 as *const libc::c_char, 0 as *mut *mut libc::c_char);
                     if !file_part.is_null() {
                         mailmime_smart_add_part(message, file_part);
@@ -897,18 +897,18 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
 
                         if 0 != dc_is_sending_locations_to_chat((*msg).context, (*msg).chat_id) {
                             let mut last_added_location_id: uint32_t = 0i32 as uint32_t;
-                            let mut kml_file: *mut libc::c_char = dc_get_location_kml(
+                            let kml_file: *mut libc::c_char = dc_get_location_kml(
                                 (*msg).context,
                                 (*msg).chat_id,
                                 &mut last_added_location_id,
                             );
                             if !kml_file.is_null() {
-                                let mut content_type: *mut mailmime_content =
+                                let content_type: *mut mailmime_content =
                                     mailmime_content_new_with_str(
                                         b"application/vnd.google-earth.kml+xml\x00" as *const u8
                                             as *const libc::c_char,
                                     );
-                                let mut mime_fields: *mut mailmime_fields =
+                                let mime_fields: *mut mailmime_fields =
                                     mailmime_fields_new_filename(
                                         MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
                                         dc_strdup(
@@ -916,7 +916,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                                         ),
                                         MAILMIME_MECHANISM_8BIT as libc::c_int,
                                     );
-                                let mut kml_mime_part: *mut mailmime =
+                                let kml_mime_part: *mut mailmime =
                                     mailmime_new_empty(content_type, mime_fields);
                                 mailmime_set_body_text(kml_mime_part, kml_file, strlen(kml_file));
                                 mailmime_smart_add_part(message, kml_mime_part);
@@ -936,9 +936,9 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
         } else if (*factory).loaded as libc::c_uint
             == DC_MF_MDN_LOADED as libc::c_int as libc::c_uint
         {
-            let mut multipart: *mut mailmime =
+            let multipart: *mut mailmime =
                 mailmime_multiple_new(b"multipart/report\x00" as *const u8 as *const libc::c_char);
-            let mut content: *mut mailmime_content = (*multipart).mm_content_type;
+            let content: *mut mailmime_content = (*multipart).mm_content_type;
             clist_insert_after(
                 (*content).ct_parameters,
                 (*(*content).ct_parameters).last,
@@ -949,8 +949,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                 ) as *mut libc::c_void,
             );
             mailmime_add_part(message, multipart);
-            let mut p1: *mut libc::c_char;
-            let mut p2: *mut libc::c_char;
+            let p1: *mut libc::c_char;
+            let p2: *mut libc::c_char;
             if 0 != dc_param_get_int((*(*factory).msg).param, 'c' as i32, 0i32) {
                 p1 = dc_stock_str((*factory).context, 24i32)
             } else {
@@ -960,7 +960,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
             message_text = dc_mprintf(b"%s\r\n\x00" as *const u8 as *const libc::c_char, p2);
             free(p2 as *mut libc::c_void);
             free(p1 as *mut libc::c_void);
-            let mut human_mime_part: *mut mailmime = build_body_text(message_text);
+            let human_mime_part: *mut mailmime = build_body_text(message_text);
             mailmime_add_part(multipart, human_mime_part);
             message_text2 =
                 dc_mprintf(b"Reporting-UA: Delta Chat %s\r\nOriginal-Recipient: rfc822;%s\r\nFinal-Recipient: rfc822;%s\r\nOriginal-Message-ID: <%s>\r\nDisposition: manual-action/MDN-sent-automatically; displayed\r\n\x00"
@@ -968,13 +968,12 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                            VERSION as *const u8 as *const libc::c_char,
                            (*factory).from_addr, (*factory).from_addr,
                            (*(*factory).msg).rfc724_mid);
-            let mut content_type_0: *mut mailmime_content = mailmime_content_new_with_str(
+            let content_type_0: *mut mailmime_content = mailmime_content_new_with_str(
                 b"message/disposition-notification\x00" as *const u8 as *const libc::c_char,
             );
-            let mut mime_fields_0: *mut mailmime_fields =
+            let mime_fields_0: *mut mailmime_fields =
                 mailmime_fields_new_encoding(MAILMIME_MECHANISM_8BIT as libc::c_int);
-            let mut mach_mime_part: *mut mailmime =
-                mailmime_new_empty(content_type_0, mime_fields_0);
+            let mach_mime_part: *mut mailmime = mailmime_new_empty(content_type_0, mime_fields_0);
             mailmime_set_body_text(mach_mime_part, message_text2, strlen(message_text2));
             mailmime_add_part(multipart, mach_mime_part);
             force_plaintext = 2i32;
@@ -992,7 +991,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
                 if (*factory).loaded as libc::c_uint
                     == DC_MF_MDN_LOADED as libc::c_int as libc::c_uint
                 {
-                    let mut e: *mut libc::c_char = dc_stock_str((*factory).context, 31i32);
+                    let e: *mut libc::c_char = dc_stock_str((*factory).context, 31i32);
                     subject_str =
                         dc_mprintf(b"Chat: %s\x00" as *const u8 as *const libc::c_char, e);
                     free(e as *mut libc::c_void);
@@ -1065,15 +1064,15 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
 }
 
 unsafe fn get_subject(
-    mut chat: *const dc_chat_t,
-    mut msg: *const dc_msg_t,
-    mut afwd_email: libc::c_int,
+    chat: *const dc_chat_t,
+    msg: *const dc_msg_t,
+    afwd_email: libc::c_int,
 ) -> *mut libc::c_char {
     let context = (*chat).context;
-    let mut ret: *mut libc::c_char;
-    let mut raw_subject: *mut libc::c_char =
+    let ret: *mut libc::c_char;
+    let raw_subject: *mut libc::c_char =
         dc_msg_get_summarytext_by_raw((*msg).type_0, (*msg).text, (*msg).param, 32i32, context);
-    let mut fwd: *const libc::c_char = if 0 != afwd_email {
+    let fwd: *const libc::c_char = if 0 != afwd_email {
         b"Fwd: \x00" as *const u8 as *const libc::c_char
     } else {
         b"\x00" as *const u8 as *const libc::c_char
@@ -1099,7 +1098,7 @@ unsafe fn get_subject(
     ret
 }
 
-unsafe fn set_error(mut factory: *mut dc_mimefactory_t, mut text: *const libc::c_char) {
+unsafe fn set_error(mut factory: *mut dc_mimefactory_t, text: *const libc::c_char) {
     if factory.is_null() {
         return;
     }
@@ -1107,10 +1106,10 @@ unsafe fn set_error(mut factory: *mut dc_mimefactory_t, mut text: *const libc::c
     (*factory).error = dc_strdup_keep_null(text);
 }
 
-unsafe fn build_body_text(mut text: *mut libc::c_char) -> *mut mailmime {
-    let mut mime_fields: *mut mailmime_fields;
-    let mut message_part: *mut mailmime;
-    let mut content: *mut mailmime_content;
+unsafe fn build_body_text(text: *mut libc::c_char) -> *mut mailmime {
+    let mime_fields: *mut mailmime_fields;
+    let message_part: *mut mailmime;
+    let content: *mut mailmime_content;
     content = mailmime_content_new_with_str(b"text/plain\x00" as *const u8 as *const libc::c_char);
     clist_insert_after(
         (*content).ct_parameters,
@@ -1128,19 +1127,19 @@ unsafe fn build_body_text(mut text: *mut libc::c_char) -> *mut mailmime {
 }
 
 unsafe fn build_body_file(
-    mut msg: *const dc_msg_t,
+    msg: *const dc_msg_t,
     mut base_name: *const libc::c_char,
-    mut ret_file_name_as_sent: *mut *mut libc::c_char,
+    ret_file_name_as_sent: *mut *mut libc::c_char,
 ) -> *mut mailmime {
-    let mut needs_ext: libc::c_int;
-    let mut mime_fields: *mut mailmime_fields;
+    let needs_ext: libc::c_int;
+    let mime_fields: *mut mailmime_fields;
     let mut mime_sub: *mut mailmime = 0 as *mut mailmime;
-    let mut content: *mut mailmime_content;
-    let mut pathNfilename: *mut libc::c_char =
+    let content: *mut mailmime_content;
+    let pathNfilename: *mut libc::c_char =
         dc_param_get((*msg).param, 'f' as i32, 0 as *const libc::c_char);
     let mut mimetype: *mut libc::c_char =
         dc_param_get((*msg).param, 'm' as i32, 0 as *const libc::c_char);
-    let mut suffix: *mut libc::c_char = dc_get_filesuffix_lc(pathNfilename);
+    let suffix: *mut libc::c_char = dc_get_filesuffix_lc(pathNfilename);
     let mut filename_to_send: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut filename_encoded: *mut libc::c_char = 0 as *mut libc::c_char;
     if !pathNfilename.is_null() {
@@ -1240,20 +1239,19 @@ unsafe fn build_body_file(
             if 0 != needs_ext {
                 let mut cur1: *mut clistiter = (*(*mime_fields).fld_list).first;
                 while !cur1.is_null() {
-                    let mut field: *mut mailmime_field = (if !cur1.is_null() {
+                    let field: *mut mailmime_field = (if !cur1.is_null() {
                         (*cur1).data
                     } else {
                         0 as *mut libc::c_void
-                    })
-                        as *mut mailmime_field;
+                    }) as *mut mailmime_field;
                     if !field.is_null()
                         && (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int
                         && !(*field).fld_data.fld_disposition.is_null()
                     {
-                        let mut file_disposition: *mut mailmime_disposition =
+                        let file_disposition: *mut mailmime_disposition =
                             (*field).fld_data.fld_disposition;
                         if !file_disposition.is_null() {
-                            let mut parm: *mut mailmime_disposition_parm =
+                            let parm: *mut mailmime_disposition_parm =
                                 mailmime_disposition_parm_new(
                                     MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int,
                                     0 as *mut libc::c_char,
@@ -1316,11 +1314,11 @@ unsafe fn build_body_file(
  * Render
  ******************************************************************************/
 
-unsafe fn is_file_size_okay(mut msg: *const dc_msg_t) -> libc::c_int {
+unsafe fn is_file_size_okay(msg: *const dc_msg_t) -> libc::c_int {
     let mut file_size_okay: libc::c_int = 1i32;
-    let mut pathNfilename: *mut libc::c_char =
+    let pathNfilename: *mut libc::c_char =
         dc_param_get((*msg).param, 'f' as i32, 0 as *const libc::c_char);
-    let mut bytes: uint64_t = dc_get_filebytes((*msg).context, pathNfilename);
+    let bytes: uint64_t = dc_get_filebytes((*msg).context, pathNfilename);
     if bytes > (49i32 * 1024i32 * 1024i32 / 4i32 * 3i32) as libc::c_ulonglong {
         file_size_okay = 0i32
     }
diff --git a/src/dc_mimeparser.rs b/src/dc_mimeparser.rs
index f4617fed8..24f99a44a 100644
--- a/src/dc_mimeparser.rs
+++ b/src/dc_mimeparser.rs
@@ -90,7 +90,7 @@ pub unsafe fn dc_mimeparser_new(
     mimeparser
 }
 
-pub unsafe fn dc_mimeparser_unref(mut mimeparser: *mut dc_mimeparser_t) {
+pub unsafe fn dc_mimeparser_unref(mimeparser: *mut dc_mimeparser_t) {
     if mimeparser.is_null() {
         return;
     }
@@ -111,10 +111,10 @@ pub unsafe fn dc_mimeparser_empty(mut mimeparser: *mut dc_mimeparser_t) {
     }
     if !(*mimeparser).parts.is_null() {
         let mut i: libc::c_int;
-        let mut cnt: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
+        let cnt: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
         i = 0i32;
         while i < cnt {
-            let mut part: *mut dc_mimepart_t =
+            let part: *mut dc_mimepart_t =
                 carray_get((*mimeparser).parts, i as libc::c_uint) as *mut dc_mimepart_t;
             if !part.is_null() {
                 dc_mimepart_unref(part);
@@ -165,12 +165,12 @@ unsafe fn dc_mimepart_unref(mut mimepart: *mut dc_mimepart_t) {
 
 pub unsafe fn dc_mimeparser_parse(
     mut mimeparser: *mut dc_mimeparser_t,
-    mut body_not_terminated: *const libc::c_char,
-    mut body_bytes: size_t,
+    body_not_terminated: *const libc::c_char,
+    body_bytes: size_t,
 ) {
-    let mut r: libc::c_int;
+    let r: libc::c_int;
     let mut index: size_t = 0i32 as size_t;
-    let mut optional_field: *mut mailimf_optional_field;
+    let optional_field: *mut mailimf_optional_field;
     dc_mimeparser_empty(mimeparser);
     r = mailmime_parse(
         body_not_terminated,
@@ -185,7 +185,7 @@ pub unsafe fn dc_mimeparser_parse(
             (*mimeparser).e2ee_helper,
         );
         dc_mimeparser_parse_mime_recursive(mimeparser, (*mimeparser).mimeroot);
-        let mut field: *mut mailimf_field = dc_mimeparser_lookup_field(
+        let field: *mut mailimf_field = dc_mimeparser_lookup_field(
             mimeparser,
             b"Subject\x00" as *const u8 as *const libc::c_char,
         );
@@ -211,7 +211,7 @@ pub unsafe fn dc_mimeparser_parse(
             let mut has_setup_file: libc::c_int = 0i32;
             i = 0i32;
             while (i as libc::c_uint) < carray_count((*mimeparser).parts) {
-                let mut part: *mut dc_mimepart_t =
+                let part: *mut dc_mimepart_t =
                     carray_get((*mimeparser).parts, i as libc::c_uint) as *mut dc_mimepart_t;
                 if (*part).int_mimetype == 111i32 {
                     has_setup_file = 1i32
@@ -222,7 +222,7 @@ pub unsafe fn dc_mimeparser_parse(
                 (*mimeparser).is_system_message = 6i32;
                 i = 0i32;
                 while (i as libc::c_uint) < carray_count((*mimeparser).parts) {
-                    let mut part_0: *mut dc_mimepart_t =
+                    let part_0: *mut dc_mimepart_t =
                         carray_get((*mimeparser).parts, i as libc::c_uint) as *mut dc_mimepart_t;
                     if (*part_0).int_mimetype != 111i32 {
                         dc_mimepart_unref(part_0);
@@ -254,7 +254,7 @@ pub unsafe fn dc_mimeparser_parse(
         .is_null()
             && carray_count((*mimeparser).parts) >= 1i32 as libc::c_uint
         {
-            let mut textpart: *mut dc_mimepart_t =
+            let textpart: *mut dc_mimepart_t =
                 carray_get((*mimeparser).parts, 0i32 as libc::c_uint) as *mut dc_mimepart_t;
             if (*textpart).type_0 == 10i32 {
                 if carray_count((*mimeparser).parts) >= 2i32 as libc::c_uint {
@@ -293,7 +293,7 @@ pub unsafe fn dc_mimeparser_parse(
         if !(*mimeparser).subject.is_null() {
             let mut prepend_subject: libc::c_int = 1i32;
             if 0 == (*mimeparser).decrypting_failed {
-                let mut p: *mut libc::c_char = strchr((*mimeparser).subject, ':' as i32);
+                let p: *mut libc::c_char = strchr((*mimeparser).subject, ':' as i32);
                 if p.wrapping_offset_from((*mimeparser).subject) as libc::c_long
                     == 2i32 as libc::c_long
                     || p.wrapping_offset_from((*mimeparser).subject) as libc::c_long
@@ -309,22 +309,22 @@ pub unsafe fn dc_mimeparser_parse(
                 }
             }
             if 0 != prepend_subject {
-                let mut subj: *mut libc::c_char = dc_strdup((*mimeparser).subject);
-                let mut p_0: *mut libc::c_char = strchr(subj, '[' as i32);
+                let subj: *mut libc::c_char = dc_strdup((*mimeparser).subject);
+                let p_0: *mut libc::c_char = strchr(subj, '[' as i32);
                 if !p_0.is_null() {
                     *p_0 = 0i32 as libc::c_char
                 }
                 dc_trim(subj);
                 if 0 != *subj.offset(0isize) {
                     let mut i_0: libc::c_int;
-                    let mut icnt: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
+                    let icnt: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
                     i_0 = 0i32;
                     while i_0 < icnt {
                         let mut part_1: *mut dc_mimepart_t =
                             carray_get((*mimeparser).parts, i_0 as libc::c_uint)
                                 as *mut dc_mimepart_t;
                         if (*part_1).type_0 == 10i32 {
-                            let mut new_txt: *mut libc::c_char = dc_mprintf(
+                            let new_txt: *mut libc::c_char = dc_mprintf(
                                 b"%s \xe2\x80\x93 %s\x00" as *const u8 as *const libc::c_char,
                                 subj,
                                 (*part_1).msg,
@@ -342,10 +342,10 @@ pub unsafe fn dc_mimeparser_parse(
         }
         if 0 != (*mimeparser).is_forwarded {
             let mut i_1: libc::c_int;
-            let mut icnt_0: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
+            let icnt_0: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
             i_1 = 0i32;
             while i_1 < icnt_0 {
-                let mut part_2: *mut dc_mimepart_t =
+                let part_2: *mut dc_mimepart_t =
                     carray_get((*mimeparser).parts, i_1 as libc::c_uint) as *mut dc_mimepart_t;
                 dc_param_set_int((*part_2).param, 'a' as i32, 1i32);
                 i_1 += 1
@@ -365,13 +365,12 @@ pub unsafe fn dc_mimeparser_parse(
                 }
             }
             if (*part_3).type_0 == 40i32 || (*part_3).type_0 == 41i32 || (*part_3).type_0 == 50i32 {
-                let mut field_0: *const mailimf_optional_field =
-                    dc_mimeparser_lookup_optional_field(
-                        mimeparser,
-                        b"Chat-Duration\x00" as *const u8 as *const libc::c_char,
-                    );
+                let field_0: *const mailimf_optional_field = dc_mimeparser_lookup_optional_field(
+                    mimeparser,
+                    b"Chat-Duration\x00" as *const u8 as *const libc::c_char,
+                );
                 if !field_0.is_null() {
-                    let mut duration_ms: libc::c_int = atoi((*field_0).fld_value);
+                    let duration_ms: libc::c_int = atoi((*field_0).fld_value);
                     if duration_ms > 0i32 && duration_ms < 24i32 * 60i32 * 60i32 * 1000i32 {
                         dc_param_set_int((*part_3).param, 'd' as i32, duration_ms);
                     }
@@ -379,7 +378,7 @@ pub unsafe fn dc_mimeparser_parse(
             }
         }
         if 0 == (*mimeparser).decrypting_failed {
-            let mut dn_field: *const mailimf_optional_field = dc_mimeparser_lookup_optional_field(
+            let dn_field: *const mailimf_optional_field = dc_mimeparser_lookup_optional_field(
                 mimeparser,
                 b"Chat-Disposition-Notification-To\x00" as *const u8 as *const libc::c_char,
             );
@@ -394,9 +393,9 @@ pub unsafe fn dc_mimeparser_parse(
                 ) == MAILIMF_NO_ERROR as libc::c_int
                     && !mb_list.is_null()
                 {
-                    let mut dn_to_addr: *mut libc::c_char = mailimf_find_first_addr(mb_list);
+                    let dn_to_addr: *mut libc::c_char = mailimf_find_first_addr(mb_list);
                     if !dn_to_addr.is_null() {
-                        let mut from_field: *mut mailimf_field = dc_mimeparser_lookup_field(
+                        let from_field: *mut mailimf_field = dc_mimeparser_lookup_field(
                             mimeparser,
                             b"From\x00" as *const u8 as *const libc::c_char,
                         );
@@ -404,12 +403,12 @@ pub unsafe fn dc_mimeparser_parse(
                             && (*from_field).fld_type == MAILIMF_FIELD_FROM as libc::c_int
                             && !(*from_field).fld_data.fld_from.is_null()
                         {
-                            let mut from_addr: *mut libc::c_char = mailimf_find_first_addr(
+                            let from_addr: *mut libc::c_char = mailimf_find_first_addr(
                                 (*(*from_field).fld_data.fld_from).frm_mb_list,
                             );
                             if !from_addr.is_null() {
                                 if strcmp(from_addr, dn_to_addr) == 0i32 {
-                                    let mut part_4: *mut dc_mimepart_t =
+                                    let part_4: *mut dc_mimepart_t =
                                         dc_mimeparser_get_last_nonmeta(mimeparser);
                                     if !part_4.is_null() {
                                         dc_param_set_int((*part_4).param, 'r' as i32, 1i32);
@@ -459,14 +458,14 @@ unsafe fn dc_mimepart_new() -> *mut dc_mimepart_t {
 }
 
 pub unsafe fn dc_mimeparser_get_last_nonmeta(
-    mut mimeparser: *mut dc_mimeparser_t,
+    mimeparser: *mut dc_mimeparser_t,
 ) -> *mut dc_mimepart_t {
     if !mimeparser.is_null() && !(*mimeparser).parts.is_null() {
         let mut i: libc::c_int;
-        let mut icnt: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
+        let icnt: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
         i = icnt - 1i32;
         while i >= 0i32 {
-            let mut part: *mut dc_mimepart_t =
+            let part: *mut dc_mimepart_t =
                 carray_get((*mimeparser).parts, i as libc::c_uint) as *mut dc_mimepart_t;
             if !part.is_null() && 0 == (*part).is_meta {
                 return part;
@@ -479,15 +478,13 @@ pub unsafe fn dc_mimeparser_get_last_nonmeta(
 }
 
 /*the result must be freed*/
-pub unsafe fn mailimf_find_first_addr(
-    mut mb_list: *const mailimf_mailbox_list,
-) -> *mut libc::c_char {
+pub unsafe fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> *mut libc::c_char {
     if mb_list.is_null() {
         return 0 as *mut libc::c_char;
     }
     let mut cur: *mut clistiter = (*(*mb_list).mb_list).first;
     while !cur.is_null() {
-        let mut mb: *mut mailimf_mailbox = (if !cur.is_null() {
+        let mb: *mut mailimf_mailbox = (if !cur.is_null() {
             (*cur).data
         } else {
             0 as *mut libc::c_void
@@ -507,8 +504,8 @@ pub unsafe fn mailimf_find_first_addr(
 
 /* the following functions can be used only after a call to dc_mimeparser_parse() */
 pub unsafe fn dc_mimeparser_lookup_field(
-    mut mimeparser: *mut dc_mimeparser_t,
-    mut field_name: *const libc::c_char,
+    mimeparser: *mut dc_mimeparser_t,
+    field_name: *const libc::c_char,
 ) -> *mut mailimf_field {
     dc_hash_find(
         &mut (*mimeparser).header,
@@ -518,10 +515,10 @@ pub unsafe fn dc_mimeparser_lookup_field(
 }
 
 pub unsafe fn dc_mimeparser_lookup_optional_field(
-    mut mimeparser: *mut dc_mimeparser_t,
-    mut field_name: *const libc::c_char,
+    mimeparser: *mut dc_mimeparser_t,
+    field_name: *const libc::c_char,
 ) -> *mut mailimf_optional_field {
-    let mut field: *mut mailimf_field = dc_hash_find(
+    let field: *mut mailimf_field = dc_hash_find(
         &mut (*mimeparser).header,
         field_name as *const libc::c_void,
         strlen(field_name) as libc::c_int,
@@ -535,7 +532,7 @@ pub unsafe fn dc_mimeparser_lookup_optional_field(
 
 unsafe fn dc_mimeparser_parse_mime_recursive(
     mut mimeparser: *mut dc_mimeparser_t,
-    mut mime: *mut mailmime,
+    mime: *mut mailmime,
 ) -> libc::c_int {
     let mut any_part_added: libc::c_int = 0i32;
     let mut cur: *mut clistiter;
@@ -606,12 +603,11 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                 10 => {
                     cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
                     while !cur.is_null() {
-                        let mut childmime: *mut mailmime = (if !cur.is_null() {
+                        let childmime: *mut mailmime = (if !cur.is_null() {
                             (*cur).data
                         } else {
                             0 as *mut libc::c_void
-                        })
-                            as *mut mailmime;
+                        }) as *mut mailmime;
                         if mailmime_get_mime_type(
                             childmime,
                             0 as *mut libc::c_int,
@@ -632,7 +628,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                     if 0 == any_part_added {
                         cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
                         while !cur.is_null() {
-                            let mut childmime_0: *mut mailmime = (if !cur.is_null() {
+                            let childmime_0: *mut mailmime = (if !cur.is_null() {
                                 (*cur).data
                             } else {
                                 0 as *mut libc::c_void
@@ -696,8 +692,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                 40 => {
                     let mut part: *mut dc_mimepart_t = dc_mimepart_new();
                     (*part).type_0 = 10i32;
-                    let mut msg_body: *mut libc::c_char =
-                        dc_stock_str((*mimeparser).context, 29i32);
+                    let msg_body: *mut libc::c_char = dc_stock_str((*mimeparser).context, 29i32);
                     (*part).msg =
                         dc_mprintf(b"[%s]\x00" as *const u8 as *const libc::c_char, msg_body);
                     (*part).msg_raw = dc_strdup((*part).msg);
@@ -725,7 +720,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                 }
                 45 => {
                     if (*(*mime).mm_data.mm_multipart.mm_mp_list).count >= 2i32 {
-                        let mut report_type: *mut mailmime_parameter = mailmime_find_ct_parameter(
+                        let report_type: *mut mailmime_parameter = mailmime_find_ct_parameter(
                             mime,
                             b"report-type\x00" as *const u8 as *const libc::c_char,
                         );
@@ -760,7 +755,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                     let mut html_cnt: libc::c_int = 0i32;
                     cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
                     while !cur.is_null() {
-                        let mut childmime_1: *mut mailmime = (if !cur.is_null() {
+                        let childmime_1: *mut mailmime = (if !cur.is_null() {
                             (*cur).data
                         } else {
                             0 as *mut libc::c_void
@@ -797,7 +792,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
                     }
                     cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
                     while !cur.is_null() {
-                        let mut childmime_2: *mut mailmime = (if !cur.is_null() {
+                        let childmime_2: *mut mailmime = (if !cur.is_null() {
                             (*cur).data
                         } else {
                             0 as *mut libc::c_void
@@ -845,7 +840,7 @@ unsafe fn hash_header(out: *mut dc_hash_t, in_0: *const mailimf_fields, _context
     }
     let mut cur1: *mut clistiter = (*(*in_0).fld_list).first;
     while !cur1.is_null() {
-        let mut field: *mut mailimf_field = (if !cur1.is_null() {
+        let field: *mut mailimf_field = (if !cur1.is_null() {
             (*cur1).data
         } else {
             0 as *mut libc::c_void
@@ -866,7 +861,7 @@ unsafe fn hash_header(out: *mut dc_hash_t, in_0: *const mailimf_fields, _context
             18 => key = b"References\x00" as *const u8 as *const libc::c_char,
             19 => key = b"Subject\x00" as *const u8 as *const libc::c_char,
             22 => {
-                let mut optional_field: *const mailimf_optional_field =
+                let optional_field: *const mailimf_optional_field =
                     (*field).fld_data.fld_optional_field;
                 if !optional_field.is_null() {
                     key = (*optional_field).fld_name
@@ -875,7 +870,7 @@ unsafe fn hash_header(out: *mut dc_hash_t, in_0: *const mailimf_fields, _context
             _ => {}
         }
         if !key.is_null() {
-            let mut key_len: libc::c_int = strlen(key) as libc::c_int;
+            let key_len: libc::c_int = strlen(key) as libc::c_int;
             if !dc_hash_find(out, key as *const libc::c_void, key_len).is_null() {
                 if (*field).fld_type != MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int
                     || key_len > 5i32
@@ -907,11 +902,11 @@ unsafe fn hash_header(out: *mut dc_hash_t, in_0: *const mailimf_fields, _context
 }
 
 unsafe fn mailmime_get_mime_type(
-    mut mime: *mut mailmime,
+    mime: *mut mailmime,
     mut msg_type: *mut libc::c_int,
-    mut raw_mime: *mut *mut libc::c_char,
+    raw_mime: *mut *mut libc::c_char,
 ) -> libc::c_int {
-    let mut c: *mut mailmime_content = (*mime).mm_content_type;
+    let c: *mut mailmime_content = (*mime).mm_content_type;
     let mut dummy: libc::c_int = 0i32;
     if msg_type.is_null() {
         msg_type = &mut dummy
@@ -1080,9 +1075,9 @@ unsafe fn mailmime_get_mime_type(
 }
 
 unsafe fn reconcat_mime(
-    mut raw_mime: *mut *mut libc::c_char,
-    mut type_0: *const libc::c_char,
-    mut subtype: *const libc::c_char,
+    raw_mime: *mut *mut libc::c_char,
+    type_0: *const libc::c_char,
+    subtype: *const libc::c_char,
 ) {
     if !raw_mime.is_null() {
         *raw_mime = dc_mprintf(
@@ -1101,11 +1096,11 @@ unsafe fn reconcat_mime(
     };
 }
 
-unsafe fn mailmime_is_attachment_disposition(mut mime: *mut mailmime) -> libc::c_int {
+unsafe fn mailmime_is_attachment_disposition(mime: *mut mailmime) -> libc::c_int {
     if !(*mime).mm_mime_fields.is_null() {
         let mut cur: *mut clistiter = (*(*(*mime).mm_mime_fields).fld_list).first;
         while !cur.is_null() {
-            let mut field: *mut mailmime_field = (if !cur.is_null() {
+            let field: *mut mailmime_field = (if !cur.is_null() {
                 (*cur).data
             } else {
                 0 as *mut libc::c_void
@@ -1134,8 +1129,8 @@ unsafe fn mailmime_is_attachment_disposition(mut mime: *mut mailmime) -> libc::c
 
 /* low-level-tools for working with mailmime structures directly */
 pub unsafe fn mailmime_find_ct_parameter(
-    mut mime: *mut mailmime,
-    mut name: *const libc::c_char,
+    mime: *mut mailmime,
+    name: *const libc::c_char,
 ) -> *mut mailmime_parameter {
     if mime.is_null()
         || name.is_null()
@@ -1147,7 +1142,7 @@ pub unsafe fn mailmime_find_ct_parameter(
     let mut cur: *mut clistiter;
     cur = (*(*(*mime).mm_content_type).ct_parameters).first;
     while !cur.is_null() {
-        let mut param: *mut mailmime_parameter = (if !cur.is_null() {
+        let param: *mut mailmime_parameter = (if !cur.is_null() {
             (*cur).data
         } else {
             0 as *mut libc::c_void
@@ -1169,14 +1164,14 @@ pub unsafe fn mailmime_find_ct_parameter(
 
 unsafe fn dc_mimeparser_add_single_part_if_known(
     mut mimeparser: *mut dc_mimeparser_t,
-    mut mime: *mut mailmime,
+    mime: *mut mailmime,
 ) -> libc::c_int {
     let mut current_block: u64;
     let mut part: *mut dc_mimepart_t = 0 as *mut dc_mimepart_t;
-    let mut old_part_count: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
-    let mut mime_type: libc::c_int;
-    let mut mime_data: *mut mailmime_data;
-    let mut file_suffix: *mut libc::c_char = 0 as *mut libc::c_char;
+    let old_part_count: libc::c_int = carray_count((*mimeparser).parts) as libc::c_int;
+    let mime_type: libc::c_int;
+    let mime_data: *mut mailmime_data;
+    let file_suffix: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut desired_filename: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut msg_type: libc::c_int = 0i32;
     let mut raw_mime: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -1223,7 +1218,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                             8795901732489102124 => {}
                             _ => {
                                 /* get from `Content-Type: text/...; charset=utf-8`; must not be free()'d */
-                                let mut charset: *const libc::c_char =
+                                let charset: *const libc::c_char =
                                     mailmime_content_charset_get((*mime).mm_content_type);
                                 if !charset.is_null()
                                     && strcmp(
@@ -1236,7 +1231,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                     ) != 0i32
                                 {
                                     let mut ret_bytes = 0;
-                                    let mut r: libc::c_int = charconv_buffer(
+                                    let r: libc::c_int = charconv_buffer(
                                         b"utf-8\x00" as *const u8 as *const libc::c_char,
                                         charset,
                                         decoded_data,
@@ -1270,7 +1265,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                     8795901732489102124 => {}
                                     _ => {
                                         /* check header directly as is_send_by_messenger is not yet set up */
-                                        let mut is_msgrmsg: libc::c_int =
+                                        let is_msgrmsg: libc::c_int =
                                             (dc_mimeparser_lookup_optional_field(
                                                 mimeparser,
                                                 b"Chat-Version\x00" as *const u8
@@ -1278,7 +1273,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                             ) != 0 as *mut libc::c_void
                                                 as *mut mailimf_optional_field)
                                                 as libc::c_int;
-                                        let mut simplified_txt: *mut libc::c_char =
+                                        let simplified_txt: *mut libc::c_char =
                                             dc_simplify_simplify(
                                                 simplifier,
                                                 decoded_data,
@@ -1325,7 +1320,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                         dc_strbuilder_init(&mut filename_parts, 0i32);
                         let mut cur1: *mut clistiter = (*(*(*mime).mm_mime_fields).fld_list).first;
                         while !cur1.is_null() {
-                            let mut field: *mut mailmime_field = (if !cur1.is_null() {
+                            let field: *mut mailmime_field = (if !cur1.is_null() {
                                 (*cur1).data
                             } else {
                                 0 as *mut libc::c_void
@@ -1335,13 +1330,13 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                                 && (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int
                                 && !(*field).fld_data.fld_disposition.is_null()
                             {
-                                let mut file_disposition: *mut mailmime_disposition =
+                                let file_disposition: *mut mailmime_disposition =
                                     (*field).fld_data.fld_disposition;
                                 if !file_disposition.is_null() {
                                     let mut cur2: *mut clistiter =
                                         (*(*file_disposition).dsp_parms).first;
                                     while !cur2.is_null() {
-                                        let mut dsp_param: *mut mailmime_disposition_parm =
+                                        let dsp_param: *mut mailmime_disposition_parm =
                                             (if !cur2.is_null() {
                                                 (*cur2).data
                                             } else {
@@ -1397,7 +1392,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
                         }
                         free(filename_parts.buf as *mut libc::c_void);
                         if desired_filename.is_null() {
-                            let mut param: *mut mailmime_parameter = mailmime_find_ct_parameter(
+                            let param: *mut mailmime_parameter = mailmime_find_ct_parameter(
                                 mime,
                                 b"name\x00" as *const u8 as *const libc::c_char,
                             );
@@ -1512,16 +1507,16 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
 }
 
 unsafe fn do_add_single_file_part(
-    mut parser: *mut dc_mimeparser_t,
-    mut msg_type: libc::c_int,
-    mut mime_type: libc::c_int,
-    mut raw_mime: *const libc::c_char,
-    mut decoded_data: *const libc::c_char,
-    mut decoded_data_bytes: size_t,
-    mut desired_filename: *const libc::c_char,
+    parser: *mut dc_mimeparser_t,
+    msg_type: libc::c_int,
+    mime_type: libc::c_int,
+    raw_mime: *const libc::c_char,
+    decoded_data: *const libc::c_char,
+    decoded_data_bytes: size_t,
+    desired_filename: *const libc::c_char,
 ) {
     let mut part: *mut dc_mimepart_t = 0 as *mut dc_mimepart_t;
-    let mut pathNfilename: *mut libc::c_char;
+    let pathNfilename: *mut libc::c_char;
     /* create a free file name to use */
     pathNfilename = dc_get_fine_pathNfilename(
         (*parser).context,
@@ -1564,7 +1559,7 @@ unsafe fn do_add_single_file_part(
     dc_mimepart_unref(part);
 }
 
-unsafe fn do_add_single_part(mut parser: *mut dc_mimeparser_t, mut part: *mut dc_mimepart_t) {
+unsafe fn do_add_single_part(parser: *mut dc_mimeparser_t, part: *mut dc_mimepart_t) {
     if 0 != (*(*parser).e2ee_helper).encrypted
         && (*(*(*parser).e2ee_helper).signatures).count > 0i32
     {
@@ -1581,15 +1576,15 @@ unsafe fn do_add_single_part(mut parser: *mut dc_mimeparser_t, mut part: *mut dc
 
 // TODO should return bool /rtn
 pub unsafe fn mailmime_transfer_decode(
-    mut mime: *mut mailmime,
-    mut ret_decoded_data: *mut *const libc::c_char,
-    mut ret_decoded_data_bytes: *mut size_t,
-    mut ret_to_mmap_string_unref: *mut *mut libc::c_char,
+    mime: *mut mailmime,
+    ret_decoded_data: *mut *const libc::c_char,
+    ret_decoded_data_bytes: *mut size_t,
+    ret_to_mmap_string_unref: *mut *mut libc::c_char,
 ) -> libc::c_int {
     let mut mime_transfer_encoding: libc::c_int = MAILMIME_MECHANISM_BINARY as libc::c_int;
-    let mut mime_data: *mut mailmime_data;
+    let mime_data: *mut mailmime_data;
     /* must not be free()'d */
-    let mut decoded_data: *const libc::c_char;
+    let decoded_data: *const libc::c_char;
     let mut decoded_data_bytes: size_t = 0i32 as size_t;
     /* mmap_string_unref()'d if set */
     let mut transfer_decoding_buffer: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -1608,7 +1603,7 @@ pub unsafe fn mailmime_transfer_decode(
         let mut cur: *mut clistiter;
         cur = (*(*(*mime).mm_mime_fields).fld_list).first;
         while !cur.is_null() {
-            let mut field: *mut mailmime_field = (if !cur.is_null() {
+            let field: *mut mailmime_field = (if !cur.is_null() {
                 (*cur).data
             } else {
                 0 as *mut libc::c_void
@@ -1638,7 +1633,7 @@ pub unsafe fn mailmime_transfer_decode(
             return 0i32;
         }
     } else {
-        let mut r: libc::c_int;
+        let r: libc::c_int;
         let mut current_index: size_t = 0i32 as size_t;
         r = mailmime_part_parse(
             (*mime_data).dt_data.dt_text.dt_data,
@@ -1665,7 +1660,7 @@ pub unsafe fn mailmime_transfer_decode(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_mimeparser_is_mailinglist_message(
-    mut mimeparser: *mut dc_mimeparser_t,
+    mimeparser: *mut dc_mimeparser_t,
 ) -> libc::c_int {
     if mimeparser.is_null() {
         return 0i32;
@@ -1678,7 +1673,7 @@ pub unsafe fn dc_mimeparser_is_mailinglist_message(
     {
         return 1i32;
     }
-    let mut precedence: *mut mailimf_optional_field = dc_mimeparser_lookup_optional_field(
+    let precedence: *mut mailimf_optional_field = dc_mimeparser_lookup_optional_field(
         mimeparser,
         b"Precedence\x00" as *const u8 as *const libc::c_char,
     );
@@ -1700,12 +1695,12 @@ pub unsafe fn dc_mimeparser_is_mailinglist_message(
 }
 
 pub unsafe fn dc_mimeparser_sender_equals_recipient(
-    mut mimeparser: *mut dc_mimeparser_t,
+    mimeparser: *mut dc_mimeparser_t,
 ) -> libc::c_int {
     let mut sender_equals_recipient: libc::c_int = 0i32;
-    let mut fld: *const mailimf_field;
+    let fld: *const mailimf_field;
     let mut fld_from: *const mailimf_from = 0 as *const mailimf_from;
-    let mut mb: *mut mailimf_mailbox;
+    let mb: *mut mailimf_mailbox;
     let mut from_addr_norm: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut recipients: *mut dc_hash_t = 0 as *mut dc_hash_t;
     if !(mimeparser.is_null() || (*mimeparser).header_root.is_null()) {
@@ -1749,21 +1744,20 @@ pub unsafe fn dc_mimeparser_sender_equals_recipient(
     sender_equals_recipient
 }
 
-pub unsafe fn mailimf_get_recipients(mut imffields: *mut mailimf_fields) -> *mut dc_hash_t {
+pub unsafe fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> *mut dc_hash_t {
     /* the returned value must be dc_hash_clear()'d and free()'d. returned addresses are normalized. */
-    let mut recipients: *mut dc_hash_t =
-        malloc(::std::mem::size_of::<dc_hash_t>()) as *mut dc_hash_t;
+    let recipients: *mut dc_hash_t = malloc(::std::mem::size_of::<dc_hash_t>()) as *mut dc_hash_t;
     dc_hash_init(recipients, 3i32, 1i32);
     let mut cur1: *mut clistiter;
     cur1 = (*(*imffields).fld_list).first;
     while !cur1.is_null() {
-        let mut fld: *mut mailimf_field = (if !cur1.is_null() {
+        let fld: *mut mailimf_field = (if !cur1.is_null() {
             (*cur1).data
         } else {
             0 as *mut libc::c_void
         }) as *mut mailimf_field;
-        let mut fld_to: *mut mailimf_to;
-        let mut fld_cc: *mut mailimf_cc;
+        let fld_to: *mut mailimf_to;
+        let fld_cc: *mut mailimf_cc;
         let mut addr_list: *mut mailimf_address_list = 0 as *mut mailimf_address_list;
         // TODO match on enums /rtn
         match (*fld).fld_type {
@@ -1785,7 +1779,7 @@ pub unsafe fn mailimf_get_recipients(mut imffields: *mut mailimf_fields) -> *mut
             let mut cur2: *mut clistiter;
             cur2 = (*(*addr_list).ad_list).first;
             while !cur2.is_null() {
-                let mut adr: *mut mailimf_address = (if !cur2.is_null() {
+                let adr: *mut mailimf_address = (if !cur2.is_null() {
                     (*cur2).data
                 } else {
                     0 as *mut libc::c_void
@@ -1794,7 +1788,7 @@ pub unsafe fn mailimf_get_recipients(mut imffields: *mut mailimf_fields) -> *mut
                     if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
                         mailimf_get_recipients__add_addr(recipients, (*adr).ad_data.ad_mailbox);
                     } else if (*adr).ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
-                        let mut group: *mut mailimf_group = (*adr).ad_data.ad_group;
+                        let group: *mut mailimf_group = (*adr).ad_data.ad_group;
                         if !group.is_null() && !(*group).grp_mb_list.is_null() {
                             let mut cur3: *mut clistiter;
                             cur3 = (*(*(*group).grp_mb_list).mb_list).first;
@@ -1840,12 +1834,9 @@ pub unsafe fn mailimf_get_recipients(mut imffields: *mut mailimf_fields) -> *mut
 /* ******************************************************************************
  * low-level-tools for getting a list of all recipients
  ******************************************************************************/
-unsafe fn mailimf_get_recipients__add_addr(
-    mut recipients: *mut dc_hash_t,
-    mut mb: *mut mailimf_mailbox,
-) {
+unsafe fn mailimf_get_recipients__add_addr(recipients: *mut dc_hash_t, mb: *mut mailimf_mailbox) {
     if !mb.is_null() {
-        let mut addr_norm: *mut libc::c_char = dc_addr_normalize((*mb).mb_addr_spec);
+        let addr_norm: *mut libc::c_char = dc_addr_normalize((*mb).mb_addr_spec);
         dc_hash_insert(
             recipients,
             addr_norm as *const libc::c_void,
@@ -1858,15 +1849,15 @@ unsafe fn mailimf_get_recipients__add_addr(
 
 /*the result is a pointer to mime, must not be freed*/
 pub unsafe fn mailimf_find_field(
-    mut header: *mut mailimf_fields,
-    mut wanted_fld_type: libc::c_int,
+    header: *mut mailimf_fields,
+    wanted_fld_type: libc::c_int,
 ) -> *mut mailimf_field {
     if header.is_null() || (*header).fld_list.is_null() {
         return 0 as *mut mailimf_field;
     }
     let mut cur1: *mut clistiter = (*(*header).fld_list).first;
     while !cur1.is_null() {
-        let mut field: *mut mailimf_field = (if !cur1.is_null() {
+        let field: *mut mailimf_field = (if !cur1.is_null() {
             (*cur1).data
         } else {
             0 as *mut libc::c_void
@@ -1887,8 +1878,8 @@ pub unsafe fn mailimf_find_field(
 }
 
 pub unsafe fn dc_mimeparser_repl_msg_by_error(
-    mut mimeparser: *mut dc_mimeparser_t,
-    mut error_msg: *const libc::c_char,
+    mimeparser: *mut dc_mimeparser_t,
+    error_msg: *const libc::c_char,
 ) {
     let mut part: *mut dc_mimepart_t;
     let mut i: libc::c_int;
@@ -1914,7 +1905,7 @@ pub unsafe fn dc_mimeparser_repl_msg_by_error(
 }
 
 /*the result is a pointer to mime, must not be freed*/
-pub unsafe fn mailmime_find_mailimf_fields(mut mime: *mut mailmime) -> *mut mailimf_fields {
+pub unsafe fn mailmime_find_mailimf_fields(mime: *mut mailmime) -> *mut mailimf_fields {
     if mime.is_null() {
         return 0 as *mut mailimf_fields;
     }
@@ -1923,7 +1914,7 @@ pub unsafe fn mailmime_find_mailimf_fields(mut mime: *mut mailmime) -> *mut mail
         2 => {
             let mut cur: *mut clistiter = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
             while !cur.is_null() {
-                let mut header: *mut mailimf_fields = mailmime_find_mailimf_fields(
+                let header: *mut mailimf_fields = mailmime_find_mailimf_fields(
                     (if !cur.is_null() {
                         (*cur).data
                     } else {
@@ -1948,22 +1939,21 @@ pub unsafe fn mailmime_find_mailimf_fields(mut mime: *mut mailmime) -> *mut mail
 }
 
 pub unsafe fn mailimf_find_optional_field(
-    mut header: *mut mailimf_fields,
-    mut wanted_fld_name: *const libc::c_char,
+    header: *mut mailimf_fields,
+    wanted_fld_name: *const libc::c_char,
 ) -> *mut mailimf_optional_field {
     if header.is_null() || (*header).fld_list.is_null() {
         return 0 as *mut mailimf_optional_field;
     }
     let mut cur1: *mut clistiter = (*(*header).fld_list).first;
     while !cur1.is_null() {
-        let mut field: *mut mailimf_field = (if !cur1.is_null() {
+        let field: *mut mailimf_field = (if !cur1.is_null() {
             (*cur1).data
         } else {
             0 as *mut libc::c_void
         }) as *mut mailimf_field;
         if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let mut optional_field: *mut mailimf_optional_field =
-                (*field).fld_data.fld_optional_field;
+            let optional_field: *mut mailimf_optional_field = (*field).fld_data.fld_optional_field;
             if !optional_field.is_null()
                 && !(*optional_field).fld_name.is_null()
                 && !(*optional_field).fld_value.is_null()
diff --git a/src/dc_move.rs b/src/dc_move.rs
index 384af8116..065bbf720 100644
--- a/src/dc_move.rs
+++ b/src/dc_move.rs
@@ -6,13 +6,13 @@ use crate::dc_sqlite3::*;
 use crate::types::*;
 
 pub unsafe fn dc_do_heuristics_moves(
-    mut context: &dc_context_t,
-    mut folder: *const libc::c_char,
-    mut msg_id: uint32_t,
+    context: &dc_context_t,
+    folder: *const libc::c_char,
+    msg_id: uint32_t,
 ) {
     // for already seen messages, folder may be different from msg->folder
     let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
-    let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !(dc_sqlite3_get_config_int(
         context,
         &context.sql.clone().read().unwrap(),
diff --git a/src/dc_msg.rs b/src/dc_msg.rs
index a3d0ec332..7ad05d233 100644
--- a/src/dc_msg.rs
+++ b/src/dc_msg.rs
@@ -45,17 +45,14 @@ pub struct dc_msg_t<'a> {
 }
 
 // handle messages
-pub unsafe fn dc_get_msg_info(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-) -> *mut libc::c_char {
-    let mut e2ee_errors: libc::c_int;
-    let mut w: libc::c_int;
-    let mut h: libc::c_int;
-    let mut duration: libc::c_int;
+pub unsafe fn dc_get_msg_info(context: &dc_context_t, msg_id: uint32_t) -> *mut libc::c_char {
+    let e2ee_errors: libc::c_int;
+    let w: libc::c_int;
+    let h: libc::c_int;
+    let duration: libc::c_int;
     let mut stmt: *mut sqlite3_stmt;
-    let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
-    let mut contact_from: *mut dc_contact_t = dc_contact_new(context);
+    let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
+    let contact_from: *mut dc_contact_t = dc_contact_new(context);
     let mut rawtxt: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut p: *mut libc::c_char;
     let mut ret: dc_strbuilder_t = dc_strbuilder_t {
@@ -132,7 +129,7 @@ pub unsafe fn dc_get_msg_info(
                 dc_strbuilder_cat(&mut ret, p);
                 free(p as *mut libc::c_void);
                 dc_strbuilder_cat(&mut ret, b" by \x00" as *const u8 as *const libc::c_char);
-                let mut contact: *mut dc_contact_t = dc_contact_new(context);
+                let contact: *mut dc_contact_t = dc_contact_new(context);
                 dc_contact_load_from_db(
                     contact,
                     &context.sql.clone().read().unwrap(),
@@ -303,8 +300,8 @@ pub unsafe fn dc_msg_new_untyped<'a>(context: &'a dc_context_t) -> *mut dc_msg_t
 // approx. max. lenght returned by dc_msg_get_text()
 // approx. max. lenght returned by dc_get_msg_info()
 pub unsafe fn dc_msg_new<'a>(
-    mut context: &'a dc_context_t,
-    mut viewtype: libc::c_int,
+    context: &'a dc_context_t,
+    viewtype: libc::c_int,
 ) -> *mut dc_msg_t<'a> {
     let mut msg: *mut dc_msg_t;
     msg = calloc(1, ::std::mem::size_of::<dc_msg_t>()) as *mut dc_msg_t;
@@ -346,7 +343,7 @@ pub unsafe fn dc_msg_empty(mut msg: *mut dc_msg_t) {
     (*msg).hidden = 0i32;
 }
 
-pub unsafe fn dc_msg_get_filemime(mut msg: *const dc_msg_t) -> *mut libc::c_char {
+pub unsafe fn dc_msg_get_filemime(msg: *const dc_msg_t) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut file: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
@@ -372,7 +369,7 @@ pub unsafe fn dc_msg_get_filemime(mut msg: *const dc_msg_t) -> *mut libc::c_char
 }
 
 pub unsafe fn dc_msg_guess_msgtype_from_suffix(
-    mut pathNfilename: *const libc::c_char,
+    pathNfilename: *const libc::c_char,
     mut ret_msgtype: *mut libc::c_int,
     mut ret_mime: *mut *mut libc::c_char,
 ) {
@@ -425,7 +422,7 @@ pub unsafe fn dc_msg_guess_msgtype_from_suffix(
     free(dummy_buf as *mut libc::c_void);
 }
 
-pub unsafe fn dc_msg_get_file(mut msg: *const dc_msg_t) -> *mut libc::c_char {
+pub unsafe fn dc_msg_get_file(msg: *const dc_msg_t) -> *mut libc::c_char {
     let mut file_rel: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut file_abs: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
@@ -452,7 +449,7 @@ pub unsafe fn dc_msg_get_file(mut msg: *const dc_msg_t) -> *mut libc::c_char {
  * @return 1=Message has location bound to it, 0=No location bound to message.
  */
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_has_location(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_has_location(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -478,7 +475,7 @@ pub unsafe fn dc_msg_has_location(mut msg: *const dc_msg_t) -> libc::c_int {
  * @return None.
  */
 pub unsafe fn dc_msg_set_location(
-    mut msg: *const dc_msg_t,
+    msg: *const dc_msg_t,
     latitude: libc::c_double,
     longitude: libc::c_double,
 ) {
@@ -497,7 +494,7 @@ pub unsafe fn dc_msg_set_location(
     );
 }
 
-pub unsafe fn dc_msg_get_timestamp(mut msg: *const dc_msg_t) -> time_t {
+pub unsafe fn dc_msg_get_timestamp(msg: *const dc_msg_t) -> time_t {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32 as time_t;
     }
@@ -540,7 +537,7 @@ pub unsafe fn dc_msg_load_from_db<'a>(
 // TODO always returns 1, should be void /rtn
 unsafe fn dc_msg_set_from_stmt(
     mut msg: *mut dc_msg_t,
-    mut row: *mut sqlite3_stmt,
+    row: *mut sqlite3_stmt,
     mut row_offset: libc::c_int,
 ) -> libc::c_int {
     dc_msg_empty(msg);
@@ -616,12 +613,9 @@ unsafe fn dc_msg_set_from_stmt(
     1
 }
 
-pub unsafe fn dc_get_mime_headers(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-) -> *mut libc::c_char {
+pub unsafe fn dc_get_mime_headers(context: &dc_context_t, msg_id: uint32_t) -> *mut libc::c_char {
     let mut eml = 0 as *mut libc::c_char;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
 
     stmt = dc_sqlite3_prepare(
         context,
@@ -639,9 +633,9 @@ pub unsafe fn dc_get_mime_headers(
 }
 
 pub unsafe fn dc_delete_msgs(
-    mut context: &dc_context_t,
-    mut msg_ids: *const uint32_t,
-    mut msg_cnt: libc::c_int,
+    context: &dc_context_t,
+    msg_ids: *const uint32_t,
+    msg_cnt: libc::c_int,
 ) {
     if msg_ids.is_null() || msg_cnt <= 0i32 {
         return;
@@ -671,11 +665,7 @@ pub unsafe fn dc_delete_msgs(
     };
 }
 
-pub unsafe fn dc_update_msg_chat_id(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-    mut chat_id: uint32_t,
-) {
+pub unsafe fn dc_update_msg_chat_id(context: &dc_context_t, msg_id: uint32_t, chat_id: uint32_t) {
     let stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -688,9 +678,9 @@ pub unsafe fn dc_update_msg_chat_id(
 }
 
 pub unsafe fn dc_markseen_msgs(
-    mut context: &dc_context_t,
-    mut msg_ids: *const uint32_t,
-    mut msg_cnt: libc::c_int,
+    context: &dc_context_t,
+    msg_ids: *const uint32_t,
+    msg_cnt: libc::c_int,
 ) {
     let mut i: libc::c_int;
     let mut send_event: libc::c_int = 0i32;
@@ -747,12 +737,8 @@ pub unsafe fn dc_markseen_msgs(
     sqlite3_finalize(stmt);
 }
 
-pub unsafe fn dc_update_msg_state(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-    mut state: libc::c_int,
-) {
-    let mut stmt = dc_sqlite3_prepare(
+pub unsafe fn dc_update_msg_state(context: &dc_context_t, msg_id: uint32_t, state: libc::c_int) {
+    let stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE msgs SET state=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
@@ -764,15 +750,15 @@ pub unsafe fn dc_update_msg_state(
 }
 
 pub unsafe fn dc_star_msgs(
-    mut context: &dc_context_t,
-    mut msg_ids: *const uint32_t,
-    mut msg_cnt: libc::c_int,
-    mut star: libc::c_int,
+    context: &dc_context_t,
+    msg_ids: *const uint32_t,
+    msg_cnt: libc::c_int,
+    star: libc::c_int,
 ) {
     if msg_ids.is_null() || msg_cnt <= 0i32 || star != 0i32 && star != 1i32 {
         return;
     }
-    let mut stmt = dc_sqlite3_prepare(
+    let stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE msgs SET starred=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
@@ -790,7 +776,7 @@ pub unsafe fn dc_star_msgs(
 
 pub unsafe fn dc_get_msg<'a>(context: &'a dc_context_t, msg_id: uint32_t) -> *mut dc_msg_t<'a> {
     let mut success: libc::c_int = 0i32;
-    let mut obj: *mut dc_msg_t = dc_msg_new_untyped(context);
+    let obj: *mut dc_msg_t = dc_msg_new_untyped(context);
     if !(0 == dc_msg_load_from_db(obj, context, msg_id)) {
         success = 1i32
     }
@@ -802,7 +788,7 @@ pub unsafe fn dc_get_msg<'a>(context: &'a dc_context_t, msg_id: uint32_t) -> *mu
     }
 }
 
-pub unsafe fn dc_msg_get_id(mut msg: *const dc_msg_t) -> uint32_t {
+pub unsafe fn dc_msg_get_id(msg: *const dc_msg_t) -> uint32_t {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32 as uint32_t;
     }
@@ -810,7 +796,7 @@ pub unsafe fn dc_msg_get_id(mut msg: *const dc_msg_t) -> uint32_t {
     (*msg).id
 }
 
-pub unsafe fn dc_msg_get_from_id(mut msg: *const dc_msg_t) -> uint32_t {
+pub unsafe fn dc_msg_get_from_id(msg: *const dc_msg_t) -> uint32_t {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32 as uint32_t;
     }
@@ -818,7 +804,7 @@ pub unsafe fn dc_msg_get_from_id(mut msg: *const dc_msg_t) -> uint32_t {
     (*msg).from_id
 }
 
-pub unsafe fn dc_msg_get_chat_id(mut msg: *const dc_msg_t) -> uint32_t {
+pub unsafe fn dc_msg_get_chat_id(msg: *const dc_msg_t) -> uint32_t {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32 as uint32_t;
     }
@@ -829,7 +815,7 @@ pub unsafe fn dc_msg_get_chat_id(mut msg: *const dc_msg_t) -> uint32_t {
     };
 }
 
-pub unsafe fn dc_msg_get_viewtype(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_get_viewtype(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -837,7 +823,7 @@ pub unsafe fn dc_msg_get_viewtype(mut msg: *const dc_msg_t) -> libc::c_int {
     (*msg).type_0
 }
 
-pub unsafe fn dc_msg_get_state(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_get_state(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -845,7 +831,7 @@ pub unsafe fn dc_msg_get_state(mut msg: *const dc_msg_t) -> libc::c_int {
     (*msg).state
 }
 
-pub unsafe fn dc_msg_get_received_timestamp(mut msg: *const dc_msg_t) -> time_t {
+pub unsafe fn dc_msg_get_received_timestamp(msg: *const dc_msg_t) -> time_t {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32 as time_t;
     }
@@ -853,7 +839,7 @@ pub unsafe fn dc_msg_get_received_timestamp(mut msg: *const dc_msg_t) -> time_t
     (*msg).timestamp_rcvd
 }
 
-pub unsafe fn dc_msg_get_sort_timestamp(mut msg: *const dc_msg_t) -> time_t {
+pub unsafe fn dc_msg_get_sort_timestamp(msg: *const dc_msg_t) -> time_t {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32 as time_t;
     }
@@ -861,8 +847,8 @@ pub unsafe fn dc_msg_get_sort_timestamp(mut msg: *const dc_msg_t) -> time_t {
     (*msg).timestamp_sort
 }
 
-pub unsafe fn dc_msg_get_text(mut msg: *const dc_msg_t) -> *mut libc::c_char {
-    let mut ret: *mut libc::c_char;
+pub unsafe fn dc_msg_get_text(msg: *const dc_msg_t) -> *mut libc::c_char {
+    let ret: *mut libc::c_char;
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return dc_strdup(0 as *const libc::c_char);
     }
@@ -872,7 +858,7 @@ pub unsafe fn dc_msg_get_text(mut msg: *const dc_msg_t) -> *mut libc::c_char {
     ret
 }
 
-pub unsafe fn dc_msg_get_filename(mut msg: *const dc_msg_t) -> *mut libc::c_char {
+pub unsafe fn dc_msg_get_filename(msg: *const dc_msg_t) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
@@ -889,7 +875,7 @@ pub unsafe fn dc_msg_get_filename(mut msg: *const dc_msg_t) -> *mut libc::c_char
     };
 }
 
-pub unsafe fn dc_msg_get_filebytes(mut msg: *const dc_msg_t) -> uint64_t {
+pub unsafe fn dc_msg_get_filebytes(msg: *const dc_msg_t) -> uint64_t {
     let mut ret: uint64_t = 0i32 as uint64_t;
     let mut file: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
@@ -903,7 +889,7 @@ pub unsafe fn dc_msg_get_filebytes(mut msg: *const dc_msg_t) -> uint64_t {
     ret
 }
 
-pub unsafe fn dc_msg_get_width(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_get_width(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -911,7 +897,7 @@ pub unsafe fn dc_msg_get_width(mut msg: *const dc_msg_t) -> libc::c_int {
     dc_param_get_int((*msg).param, 'w' as i32, 0i32)
 }
 
-pub unsafe fn dc_msg_get_height(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_get_height(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -920,7 +906,7 @@ pub unsafe fn dc_msg_get_height(mut msg: *const dc_msg_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_get_duration(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_get_duration(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -929,7 +915,7 @@ pub unsafe fn dc_msg_get_duration(mut msg: *const dc_msg_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_get_showpadlock(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_get_showpadlock(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -944,8 +930,8 @@ pub unsafe fn dc_msg_get_summary<'a>(
     msg: *const dc_msg_t<'a>,
     mut chat: *const dc_chat_t<'a>,
 ) -> *mut dc_lot_t {
-    let mut current_block: u64;
-    let mut ret: *mut dc_lot_t = dc_lot_new();
+    let current_block: u64;
+    let ret: *mut dc_lot_t = dc_lot_new();
     let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
     let mut chat_to_delete: *mut dc_chat_t = 0 as *mut dc_chat_t;
     if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
@@ -979,8 +965,8 @@ pub unsafe fn dc_msg_get_summary<'a>(
 }
 
 pub unsafe fn dc_msg_get_summarytext(
-    mut msg: *const dc_msg_t,
-    mut approx_characters: libc::c_int,
+    msg: *const dc_msg_t,
+    approx_characters: libc::c_int,
 ) -> *mut libc::c_char {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return dc_strdup(0 as *const libc::c_char);
@@ -997,11 +983,11 @@ pub unsafe fn dc_msg_get_summarytext(
 
 /* the returned value must be free()'d */
 pub unsafe fn dc_msg_get_summarytext_by_raw(
-    mut type_0: libc::c_int,
-    mut text: *const libc::c_char,
-    mut param: *mut dc_param_t,
-    mut approx_characters: libc::c_int,
-    mut context: &dc_context_t,
+    type_0: libc::c_int,
+    text: *const libc::c_char,
+    param: *mut dc_param_t,
+    approx_characters: libc::c_int,
+    context: &dc_context_t,
 ) -> *mut libc::c_char {
     /* get a summary text, result must be free()'d, never returns NULL. */
     let mut ret;
@@ -1070,17 +1056,17 @@ pub unsafe fn dc_msg_get_summarytext_by_raw(
     ret
 }
 
-pub unsafe fn dc_msg_has_deviating_timestamp(mut msg: *const dc_msg_t) -> libc::c_int {
-    let mut cnv_to_local: libc::c_long = dc_gm2local_offset();
-    let mut sort_timestamp: time_t = dc_msg_get_sort_timestamp(msg) + cnv_to_local;
-    let mut send_timestamp: time_t = dc_msg_get_timestamp(msg) + cnv_to_local;
+pub unsafe fn dc_msg_has_deviating_timestamp(msg: *const dc_msg_t) -> libc::c_int {
+    let cnv_to_local: libc::c_long = dc_gm2local_offset();
+    let sort_timestamp: time_t = dc_msg_get_sort_timestamp(msg) + cnv_to_local;
+    let send_timestamp: time_t = dc_msg_get_timestamp(msg) + cnv_to_local;
 
     (sort_timestamp / 86400i32 as libc::c_long != send_timestamp / 86400i32 as libc::c_long)
         as libc::c_int
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_is_sent(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_is_sent(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -1088,7 +1074,7 @@ pub unsafe fn dc_msg_is_sent(mut msg: *const dc_msg_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_is_starred(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_is_starred(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -1096,7 +1082,7 @@ pub unsafe fn dc_msg_is_starred(mut msg: *const dc_msg_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_is_forwarded(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_is_forwarded(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -1108,11 +1094,11 @@ pub unsafe fn dc_msg_is_forwarded(mut msg: *const dc_msg_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_is_info(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_is_info(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
-    let mut cmd: libc::c_int = dc_param_get_int((*msg).param, 'S' as i32, 0i32);
+    let cmd: libc::c_int = dc_param_get_int((*msg).param, 'S' as i32, 0i32);
     if (*msg).from_id == 2i32 as libc::c_uint
         || (*msg).to_id == 2i32 as libc::c_uint
         || 0 != cmd && cmd != 6i32
@@ -1124,7 +1110,7 @@ pub unsafe fn dc_msg_is_info(mut msg: *const dc_msg_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_is_increation(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_is_increation(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return 0i32;
     }
@@ -1139,7 +1125,7 @@ pub unsafe fn dc_msg_is_increation(mut msg: *const dc_msg_t) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_msg_is_setupmessage(mut msg: *const dc_msg_t) -> libc::c_int {
+pub unsafe fn dc_msg_is_setupmessage(msg: *const dc_msg_t) -> libc::c_int {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint || (*msg).type_0 != 60i32 {
         return 0i32;
     }
@@ -1150,7 +1136,7 @@ pub unsafe fn dc_msg_is_setupmessage(mut msg: *const dc_msg_t) -> libc::c_int {
     };
 }
 
-pub unsafe fn dc_msg_get_setupcodebegin(mut msg: *const dc_msg_t) -> *mut libc::c_char {
+pub unsafe fn dc_msg_get_setupcodebegin(msg: *const dc_msg_t) -> *mut libc::c_char {
     let mut filename: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut buf: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut buf_bytes: size_t = 0i32 as size_t;
@@ -1200,7 +1186,7 @@ pub unsafe fn dc_msg_get_setupcodebegin(mut msg: *const dc_msg_t) -> *mut libc::
     };
 }
 
-pub unsafe fn dc_msg_set_text(mut msg: *mut dc_msg_t, mut text: *const libc::c_char) {
+pub unsafe fn dc_msg_set_text(mut msg: *mut dc_msg_t, text: *const libc::c_char) {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return;
     }
@@ -1210,9 +1196,9 @@ pub unsafe fn dc_msg_set_text(mut msg: *mut dc_msg_t, mut text: *const libc::c_c
 
 // TODO should return bool /rtn
 pub unsafe fn dc_msg_set_file(
-    mut msg: *mut dc_msg_t,
-    mut file: *const libc::c_char,
-    mut filemime: *const libc::c_char,
+    msg: *mut dc_msg_t,
+    file: *const libc::c_char,
+    filemime: *const libc::c_char,
 ) {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return;
@@ -1221,11 +1207,7 @@ pub unsafe fn dc_msg_set_file(
     dc_param_set((*msg).param, 'm' as i32, filemime);
 }
 
-pub unsafe fn dc_msg_set_dimension(
-    mut msg: *mut dc_msg_t,
-    mut width: libc::c_int,
-    mut height: libc::c_int,
-) {
+pub unsafe fn dc_msg_set_dimension(msg: *mut dc_msg_t, width: libc::c_int, height: libc::c_int) {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return;
     }
@@ -1233,7 +1215,7 @@ pub unsafe fn dc_msg_set_dimension(
     dc_param_set_int((*msg).param, 'h' as i32, height);
 }
 
-pub unsafe fn dc_msg_set_duration(mut msg: *mut dc_msg_t, mut duration: libc::c_int) {
+pub unsafe fn dc_msg_set_duration(msg: *mut dc_msg_t, duration: libc::c_int) {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return;
     }
@@ -1241,10 +1223,10 @@ pub unsafe fn dc_msg_set_duration(mut msg: *mut dc_msg_t, mut duration: libc::c_
 }
 
 pub unsafe fn dc_msg_latefiling_mediasize(
-    mut msg: *mut dc_msg_t,
-    mut width: libc::c_int,
-    mut height: libc::c_int,
-    mut duration: libc::c_int,
+    msg: *mut dc_msg_t,
+    width: libc::c_int,
+    height: libc::c_int,
+    duration: libc::c_int,
 ) {
     if !(msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint) {
         if width > 0i32 && height > 0i32 {
@@ -1258,11 +1240,11 @@ pub unsafe fn dc_msg_latefiling_mediasize(
     };
 }
 
-pub unsafe fn dc_msg_save_param_to_disk(mut msg: *mut dc_msg_t) {
+pub unsafe fn dc_msg_save_param_to_disk(msg: *mut dc_msg_t) {
     if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
         return;
     }
-    let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+    let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
         (*msg).context,
         &mut (*msg).context.sql.clone().read().unwrap(),
         b"UPDATE msgs SET param=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
@@ -1277,13 +1259,13 @@ pub unsafe fn dc_msg_new_load<'a>(
     context: &'a dc_context_t,
     msg_id: uint32_t,
 ) -> *mut dc_msg_t<'a> {
-    let mut msg = dc_msg_new_untyped(context);
+    let msg = dc_msg_new_untyped(context);
     dc_msg_load_from_db(msg, context, msg_id);
     msg
 }
 
-pub unsafe fn dc_delete_msg_from_db(context: &dc_context_t, mut msg_id: uint32_t) {
-    let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
+pub unsafe fn dc_delete_msg_from_db(context: &dc_context_t, msg_id: uint32_t) {
+    let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !(0 == dc_msg_load_from_db(msg, context, msg_id)) {
         stmt = dc_sqlite3_prepare(
@@ -1328,7 +1310,7 @@ pub unsafe fn dc_msg_exists(context: &dc_context_t, msg_id: uint32_t) -> libc::c
         sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
 
         if sqlite3_step(stmt) == 100i32 {
-            let mut chat_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
+            let chat_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
             if chat_id != 3i32 as libc::c_uint {
                 msg_exists = 1i32
             }
@@ -1340,13 +1322,13 @@ pub unsafe fn dc_msg_exists(context: &dc_context_t, msg_id: uint32_t) -> libc::c
 }
 
 pub unsafe fn dc_update_msg_move_state(
-    mut context: &dc_context_t,
-    mut rfc724_mid: *const libc::c_char,
-    mut state: dc_move_state_t,
+    context: &dc_context_t,
+    rfc724_mid: *const libc::c_char,
+    state: dc_move_state_t,
 ) {
     // we update the move_state for all messages belonging to a given Message-ID
     // so that the state stay intact when parts are deleted
-    let mut stmt = dc_sqlite3_prepare(
+    let stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE msgs SET move_state=? WHERE rfc724_mid=?;\x00" as *const u8 as *const libc::c_char,
@@ -1358,9 +1340,9 @@ pub unsafe fn dc_update_msg_move_state(
 }
 
 pub unsafe fn dc_set_msg_failed(
-    mut context: &dc_context_t,
-    mut msg_id: uint32_t,
-    mut error: *const libc::c_char,
+    context: &dc_context_t,
+    msg_id: uint32_t,
+    error: *const libc::c_char,
 ) {
     let mut msg = dc_msg_new_untyped(context);
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -1399,18 +1381,18 @@ pub unsafe fn dc_set_msg_failed(
 
 /* returns 1 if an event should be send */
 pub unsafe fn dc_mdn_from_ext(
-    mut context: &dc_context_t,
-    mut from_id: uint32_t,
-    mut rfc724_mid: *const libc::c_char,
-    mut timestamp_sent: time_t,
-    mut ret_chat_id: *mut uint32_t,
-    mut ret_msg_id: *mut uint32_t,
+    context: &dc_context_t,
+    from_id: uint32_t,
+    rfc724_mid: *const libc::c_char,
+    timestamp_sent: time_t,
+    ret_chat_id: *mut uint32_t,
+    ret_msg_id: *mut uint32_t,
 ) -> libc::c_int {
-    let mut chat_type: libc::c_int;
-    let mut msg_state: libc::c_int;
-    let mut mdn_already_in_table: libc::c_int;
-    let mut ist_cnt: libc::c_int;
-    let mut soll_cnt: libc::c_int;
+    let chat_type: libc::c_int;
+    let msg_state: libc::c_int;
+    let mdn_already_in_table: libc::c_int;
+    let ist_cnt: libc::c_int;
+    let soll_cnt: libc::c_int;
     let mut read_by_all: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !(from_id <= 9i32 as libc::c_uint
@@ -1515,7 +1497,7 @@ pub unsafe fn dc_mdn_from_ext(
 }
 
 /* the number of messages assigned to real chat (!=deaddrop, !=trash) */
-pub unsafe fn dc_get_real_msg_cnt(mut context: &dc_context_t) -> size_t {
+pub unsafe fn dc_get_real_msg_cnt(context: &dc_context_t) -> size_t {
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut ret: size_t = 0i32 as size_t;
     if !(*&context.sql.clone().read().unwrap()).cobj.is_null() {
@@ -1540,7 +1522,7 @@ pub unsafe fn dc_get_real_msg_cnt(mut context: &dc_context_t) -> size_t {
     ret
 }
 
-pub unsafe fn dc_get_deaddrop_msg_cnt(mut context: &dc_context_t) -> size_t {
+pub unsafe fn dc_get_deaddrop_msg_cnt(context: &dc_context_t) -> size_t {
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     let mut ret: size_t = 0i32 as size_t;
     if !context.sql.clone().read().unwrap().cobj.is_null() {
@@ -1558,8 +1540,8 @@ pub unsafe fn dc_get_deaddrop_msg_cnt(mut context: &dc_context_t) -> size_t {
 }
 
 pub unsafe fn dc_rfc724_mid_cnt(
-    mut context: &dc_context_t,
-    mut rfc724_mid: *const libc::c_char,
+    context: &dc_context_t,
+    rfc724_mid: *const libc::c_char,
 ) -> libc::c_int {
     /* check the number of messages with the same rfc724_mid */
     let mut ret: libc::c_int = 0i32;
@@ -1582,10 +1564,10 @@ pub unsafe fn dc_rfc724_mid_cnt(
 }
 
 pub unsafe fn dc_rfc724_mid_exists(
-    mut context: &dc_context_t,
-    mut rfc724_mid: *const libc::c_char,
-    mut ret_server_folder: *mut *mut libc::c_char,
-    mut ret_server_uid: *mut uint32_t,
+    context: &dc_context_t,
+    rfc724_mid: *const libc::c_char,
+    ret_server_folder: *mut *mut libc::c_char,
+    ret_server_uid: *mut uint32_t,
 ) -> uint32_t {
     let mut ret: uint32_t = 0i32 as uint32_t;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -1620,12 +1602,12 @@ pub unsafe fn dc_rfc724_mid_exists(
 }
 
 pub unsafe fn dc_update_server_uid(
-    mut context: &dc_context_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,
 ) {
-    let mut stmt = dc_sqlite3_prepare(
+    let stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
         b"UPDATE msgs SET server_folder=?, server_uid=? WHERE rfc724_mid=?;\x00" as *const u8
diff --git a/src/dc_oauth2.rs b/src/dc_oauth2.rs
index 9d47e3e45..1e34bf994 100644
--- a/src/dc_oauth2.rs
+++ b/src/dc_oauth2.rs
@@ -20,9 +20,9 @@ pub struct oauth2_t {
 }
 
 pub unsafe fn dc_get_oauth2_url(
-    mut context: &dc_context_t,
-    mut addr: *const libc::c_char,
-    mut redirect_uri: *const libc::c_char,
+    context: &dc_context_t,
+    addr: *const libc::c_char,
+    redirect_uri: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t;
     let mut oauth2_url: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -54,20 +54,20 @@ pub unsafe fn dc_get_oauth2_url(
 }
 
 unsafe fn replace_in_uri(
-    mut uri: *mut *mut libc::c_char,
-    mut key: *const libc::c_char,
-    mut value: *const libc::c_char,
+    uri: *mut *mut libc::c_char,
+    key: *const libc::c_char,
+    value: *const libc::c_char,
 ) {
     if !uri.is_null() && !key.is_null() && !value.is_null() {
-        let mut value_urlencoded: *mut libc::c_char = dc_urlencode(value);
+        let value_urlencoded: *mut libc::c_char = dc_urlencode(value);
         dc_str_replace(uri, key, value_urlencoded);
         free(value_urlencoded as *mut libc::c_void);
     };
 }
 
-unsafe fn get_info(mut addr: *const libc::c_char) -> *mut oauth2_t {
+unsafe fn get_info(addr: *const libc::c_char) -> *mut oauth2_t {
     let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t;
-    let mut addr_normalized: *mut libc::c_char;
+    let addr_normalized: *mut libc::c_char;
     let mut domain: *const libc::c_char;
     addr_normalized = dc_addr_normalize(addr);
     domain = strchr(addr_normalized, '@' as i32);
@@ -124,12 +124,12 @@ unsafe fn get_info(mut addr: *const libc::c_char) -> *mut oauth2_t {
 // the following function may block due http-requests;
 // must not be called from the main thread or by the ui!
 pub unsafe fn dc_get_oauth2_access_token(
-    mut context: &dc_context_t,
-    mut addr: *const libc::c_char,
-    mut code: *const libc::c_char,
-    mut flags: libc::c_int,
+    context: &dc_context_t,
+    addr: *const libc::c_char,
+    code: *const libc::c_char,
+    flags: libc::c_int,
 ) -> *mut libc::c_char {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t;
     let mut access_token: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut refresh_token: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -153,7 +153,7 @@ pub unsafe fn dc_get_oauth2_access_token(
         end: 0,
         size: 0,
     }; 128];
-    let mut tok_cnt: libc::c_int;
+    let tok_cnt: libc::c_int;
     if code.is_null() || *code.offset(0isize) as libc::c_int == 0i32 {
         dc_log_warning(
             context,
@@ -320,12 +320,12 @@ pub unsafe fn dc_get_oauth2_access_token(
                                     b"expires_in\x00" as *const u8 as *const libc::c_char,
                                 ) == 0i32
                                 {
-                                    let mut expires_in_str: *mut libc::c_char = jsondup(
+                                    let expires_in_str: *mut libc::c_char = jsondup(
                                         json,
                                         &mut *tok.as_mut_ptr().offset((i + 1i32) as isize),
                                     );
                                     if !expires_in_str.is_null() {
-                                        let mut val: time_t = atol(expires_in_str);
+                                        let val: time_t = atol(expires_in_str);
                                         if val > 20i32 as libc::c_long
                                             && val
                                                 < (60i32 * 60i32 * 24i32 * 365i32 * 5i32)
@@ -456,7 +456,7 @@ pub unsafe fn dc_get_oauth2_access_token(
     };
 }
 
-unsafe fn jsondup(mut json: *const libc::c_char, mut tok: *mut jsmntok_t) -> *mut libc::c_char {
+unsafe fn jsondup(json: *const libc::c_char, tok: *mut jsmntok_t) -> *mut libc::c_char {
     if (*tok).type_0 as libc::c_uint == JSMN_STRING as libc::c_int as libc::c_uint
         || (*tok).type_0 as libc::c_uint == JSMN_PRIMITIVE as libc::c_int as libc::c_uint
     {
@@ -470,9 +470,9 @@ unsafe fn jsondup(mut json: *const libc::c_char, mut tok: *mut jsmntok_t) -> *mu
 }
 
 unsafe extern "C" fn jsoneq(
-    mut json: *const libc::c_char,
-    mut tok: *mut jsmntok_t,
-    mut s: *const libc::c_char,
+    json: *const libc::c_char,
+    tok: *mut jsmntok_t,
+    s: *const libc::c_char,
 ) -> libc::c_int {
     if (*tok).type_0 as libc::c_uint == JSMN_STRING as libc::c_int as libc::c_uint
         && strlen(s) as libc::c_int == (*tok).end - (*tok).start
@@ -489,8 +489,8 @@ unsafe extern "C" fn jsoneq(
 }
 
 // TODO should return bool /rtn
-unsafe fn is_expired(mut context: &dc_context_t) -> libc::c_int {
-    let mut expire_timestamp: time_t = dc_sqlite3_get_config_int64(
+unsafe fn is_expired(context: &dc_context_t) -> libc::c_int {
+    let expire_timestamp: time_t = dc_sqlite3_get_config_int64(
         context,
         &context.sql.clone().read().unwrap(),
         b"oauth2_timestamp_expires\x00" as *const u8 as *const libc::c_char,
@@ -507,13 +507,13 @@ unsafe fn is_expired(mut context: &dc_context_t) -> libc::c_int {
 }
 
 pub unsafe fn dc_get_oauth2_addr(
-    mut context: &dc_context_t,
-    mut addr: *const libc::c_char,
-    mut code: *const libc::c_char,
+    context: &dc_context_t,
+    addr: *const libc::c_char,
+    code: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut access_token: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut addr_out: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut oauth2: *mut oauth2_t;
+    let oauth2: *mut oauth2_t;
     if !({
         oauth2 = get_info(addr);
         oauth2.is_null()
@@ -534,9 +534,9 @@ pub unsafe fn dc_get_oauth2_addr(
 }
 
 unsafe fn get_oauth2_addr(
-    mut context: &dc_context_t,
-    mut oauth2: *const oauth2_t,
-    mut access_token: *const libc::c_char,
+    context: &dc_context_t,
+    oauth2: *const oauth2_t,
+    access_token: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut addr_out: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut userinfo_url: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -553,7 +553,7 @@ unsafe fn get_oauth2_addr(
         end: 0,
         size: 0,
     }; 128];
-    let mut tok_cnt: libc::c_int;
+    let tok_cnt: libc::c_int;
     if !(access_token.is_null()
         || *access_token.offset(0isize) as libc::c_int == 0i32
         || oauth2.is_null())
diff --git a/src/dc_param.rs b/src/dc_param.rs
index 6ccf9f55c..4d9250f00 100644
--- a/src/dc_param.rs
+++ b/src/dc_param.rs
@@ -75,7 +75,7 @@ pub struct dc_param_t {
 
 // values for DC_PARAM_FORCE_PLAINTEXT
 /* user functions */
-pub unsafe fn dc_param_exists(mut param: *mut dc_param_t, mut key: libc::c_int) -> libc::c_int {
+pub unsafe fn dc_param_exists(param: *mut dc_param_t, key: libc::c_int) -> libc::c_int {
     let mut p2: *mut libc::c_char = 0 as *mut libc::c_char;
     if param.is_null() || key == 0i32 {
         return 0i32;
@@ -88,9 +88,9 @@ pub unsafe fn dc_param_exists(mut param: *mut dc_param_t, mut key: libc::c_int)
 }
 
 unsafe extern "C" fn find_param(
-    mut haystack: *mut libc::c_char,
-    mut key: libc::c_int,
-    mut ret_p2: *mut *mut libc::c_char,
+    haystack: *mut libc::c_char,
+    key: libc::c_int,
+    ret_p2: *mut *mut libc::c_char,
 ) -> *mut libc::c_char {
     let mut p1: *mut libc::c_char;
     let mut p2: *mut libc::c_char;
@@ -125,8 +125,8 @@ pub unsafe fn dc_param_get(
 ) -> *mut libc::c_char {
     let mut p1: *mut libc::c_char;
     let mut p2: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut bak: libc::c_char;
-    let mut ret: *mut libc::c_char;
+    let bak: libc::c_char;
+    let ret: *mut libc::c_char;
     if param.is_null() || key == 0i32 {
         return if !def.is_null() {
             dc_strdup(def)
@@ -153,18 +153,18 @@ pub unsafe fn dc_param_get(
 }
 
 pub unsafe fn dc_param_get_int(
-    mut param: *const dc_param_t,
-    mut key: libc::c_int,
-    mut def: int32_t,
+    param: *const dc_param_t,
+    key: libc::c_int,
+    def: int32_t,
 ) -> int32_t {
     if param.is_null() || key == 0i32 {
         return def;
     }
-    let mut str: *mut libc::c_char = dc_param_get(param, key, 0 as *const libc::c_char);
+    let str: *mut libc::c_char = dc_param_get(param, key, 0 as *const libc::c_char);
     if str.is_null() {
         return def;
     }
-    let mut ret: int32_t = atol(str) as int32_t;
+    let ret: int32_t = atol(str) as int32_t;
     free(str as *mut libc::c_void);
 
     ret
@@ -188,7 +188,7 @@ pub unsafe fn dc_param_get_float(
         return def;
     }
 
-    let mut str = dc_param_get(param, key, std::ptr::null());
+    let str = dc_param_get(param, key, std::ptr::null());
     if str.is_null() {
         return def;
     }
@@ -201,19 +201,19 @@ pub unsafe fn dc_param_get_float(
 
 pub unsafe fn dc_param_set(
     mut param: *mut dc_param_t,
-    mut key: libc::c_int,
-    mut value: *const libc::c_char,
+    key: libc::c_int,
+    value: *const libc::c_char,
 ) {
     let mut old1: *mut libc::c_char;
     let mut old2: *mut libc::c_char;
-    let mut new1: *mut libc::c_char;
+    let new1: *mut libc::c_char;
     if param.is_null() || key == 0i32 {
         return;
     }
     old1 = (*param).packed;
     old2 = 0 as *mut libc::c_char;
     if !old1.is_null() {
-        let mut p1: *mut libc::c_char;
+        let p1: *mut libc::c_char;
         let mut p2: *mut libc::c_char = 0 as *mut libc::c_char;
         p1 = find_param(old1, key, &mut p2);
         if !p1.is_null() {
@@ -281,15 +281,11 @@ pub unsafe fn dc_param_set(
     (*param).packed = new1;
 }
 
-pub unsafe fn dc_param_set_int(
-    mut param: *mut dc_param_t,
-    mut key: libc::c_int,
-    mut value: int32_t,
-) {
+pub unsafe fn dc_param_set_int(param: *mut dc_param_t, key: libc::c_int, value: int32_t) {
     if param.is_null() || key == 0i32 {
         return;
     }
-    let mut value_str: *mut libc::c_char = dc_mprintf(
+    let value_str: *mut libc::c_char = dc_mprintf(
         b"%i\x00" as *const u8 as *const libc::c_char,
         value as libc::c_int,
     );
@@ -312,14 +308,14 @@ pub unsafe fn dc_param_new() -> *mut dc_param_t {
     param
 }
 
-pub unsafe fn dc_param_empty(mut param: *mut dc_param_t) {
+pub unsafe fn dc_param_empty(param: *mut dc_param_t) {
     if param.is_null() {
         return;
     }
     *(*param).packed.offset(0isize) = 0i32 as libc::c_char;
 }
 
-pub unsafe fn dc_param_unref(mut param: *mut dc_param_t) {
+pub unsafe fn dc_param_unref(param: *mut dc_param_t) {
     if param.is_null() {
         return;
     }
@@ -328,7 +324,7 @@ pub unsafe fn dc_param_unref(mut param: *mut dc_param_t) {
     free(param as *mut libc::c_void);
 }
 
-pub unsafe fn dc_param_set_packed(mut param: *mut dc_param_t, mut packed: *const libc::c_char) {
+pub unsafe fn dc_param_set_packed(mut param: *mut dc_param_t, packed: *const libc::c_char) {
     if param.is_null() {
         return;
     }
@@ -339,10 +335,7 @@ pub unsafe fn dc_param_set_packed(mut param: *mut dc_param_t, mut packed: *const
     };
 }
 
-pub unsafe fn dc_param_set_urlencoded(
-    mut param: *mut dc_param_t,
-    mut urlencoded: *const libc::c_char,
-) {
+pub unsafe fn dc_param_set_urlencoded(mut param: *mut dc_param_t, urlencoded: *const libc::c_char) {
     if param.is_null() {
         return;
     }
diff --git a/src/dc_pgp.rs b/src/dc_pgp.rs
index 6796276ce..453006456 100644
--- a/src/dc_pgp.rs
+++ b/src/dc_pgp.rs
@@ -12,11 +12,11 @@ pub unsafe fn dc_pgp_exit() {}
 
 // TODO should return bool /rtn
 pub unsafe fn dc_split_armored_data(
-    mut buf: *mut libc::c_char,
-    mut ret_headerline: *mut *const libc::c_char,
-    mut ret_setupcodebegin: *mut *const libc::c_char,
-    mut ret_preferencrypt: *mut *const libc::c_char,
-    mut ret_base64: *mut *const libc::c_char,
+    buf: *mut libc::c_char,
+    ret_headerline: *mut *const libc::c_char,
+    ret_setupcodebegin: *mut *const libc::c_char,
+    ret_preferencrypt: *mut *const libc::c_char,
+    ret_base64: *mut *const libc::c_char,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut line_chars: size_t = 0i32 as size_t;
@@ -132,17 +132,17 @@ pub unsafe fn dc_split_armored_data(
 /* public key encryption */
 // TODO should return bool /rtn
 pub unsafe fn dc_pgp_create_keypair(
-    mut context: &dc_context_t,
-    mut addr: *const libc::c_char,
-    mut ret_public_key: *mut dc_key_t,
-    mut ret_private_key: *mut dc_key_t,
+    context: &dc_context_t,
+    addr: *const libc::c_char,
+    ret_public_key: *mut dc_key_t,
+    ret_private_key: *mut dc_key_t,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
-    let mut skey: *mut rpgp::signed_secret_key;
+    let skey: *mut rpgp::signed_secret_key;
     let mut pkey: *mut rpgp::signed_public_key = 0 as *mut rpgp::signed_public_key;
     let mut skey_bytes: *mut rpgp::cvec = 0 as *mut rpgp::cvec;
     let mut pkey_bytes: *mut rpgp::cvec = 0 as *mut rpgp::cvec;
-    let mut user_id: *mut libc::c_char;
+    let user_id: *mut libc::c_char;
     user_id = dc_mprintf(b"<%s>\x00" as *const u8 as *const libc::c_char, addr);
     skey = rpgp::rpgp_create_rsa_skey(2048i32 as uint32_t, user_id);
     if !(0 != dc_pgp_handle_rpgp_error(context)) {
@@ -195,9 +195,9 @@ pub unsafe fn dc_pgp_create_keypair(
 
 /* returns 0 if there is no error, otherwise logs the error if a context is provided and returns 1*/
 // TODO should return bool /rtn
-pub unsafe fn dc_pgp_handle_rpgp_error(mut context: &dc_context_t) -> libc::c_int {
+pub unsafe fn dc_pgp_handle_rpgp_error(context: &dc_context_t) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
-    let mut len: libc::c_int;
+    let len: libc::c_int;
     let mut msg: *mut libc::c_char = 0 as *mut libc::c_char;
     len = rpgp::rpgp_last_error_length();
     if !(len == 0i32) {
@@ -218,10 +218,7 @@ pub unsafe fn dc_pgp_handle_rpgp_error(mut context: &dc_context_t) -> libc::c_in
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_pgp_is_valid_key(
-    mut context: &dc_context_t,
-    mut raw_key: *const dc_key_t,
-) -> libc::c_int {
+pub unsafe fn dc_pgp_is_valid_key(context: &dc_context_t, raw_key: *const dc_key_t) -> libc::c_int {
     let mut key_is_valid: libc::c_int = 0i32;
     let mut key: *mut rpgp::public_or_secret_key = 0 as *mut rpgp::public_or_secret_key;
     if !(raw_key.is_null() || (*raw_key).binary.is_null() || (*raw_key).bytes <= 0i32) {
@@ -293,9 +290,9 @@ pub unsafe fn dc_pgp_calc_fingerprint(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_pgp_split_key(
-    mut context: &dc_context_t,
-    mut private_in: *const dc_key_t,
-    mut ret_public_key: *mut dc_key_t,
+    context: &dc_context_t,
+    private_in: *const dc_key_t,
+    ret_public_key: *mut dc_key_t,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut key: *mut rpgp::signed_secret_key = 0 as *mut rpgp::signed_secret_key;
@@ -345,14 +342,14 @@ pub unsafe fn dc_pgp_split_key(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_pgp_pk_encrypt(
-    mut context: &dc_context_t,
-    mut plain_text: *const libc::c_void,
-    mut plain_bytes: size_t,
-    mut raw_public_keys_for_encryption: *const dc_keyring_t,
-    mut raw_private_key_for_signing: *const dc_key_t,
-    mut use_armor: libc::c_int,
-    mut ret_ctext: *mut *mut libc::c_void,
-    mut ret_ctext_bytes: *mut size_t,
+    context: &dc_context_t,
+    plain_text: *const libc::c_void,
+    plain_bytes: size_t,
+    raw_public_keys_for_encryption: *const dc_keyring_t,
+    raw_private_key_for_signing: *const dc_key_t,
+    use_armor: libc::c_int,
+    ret_ctext: *mut *mut libc::c_void,
+    ret_ctext_bytes: *mut size_t,
 ) -> libc::c_int {
     let mut current_block: u64;
     let mut i: libc::c_int;
@@ -423,8 +420,8 @@ pub unsafe fn dc_pgp_pk_encrypt(
                     2132137392766895896 => {}
                     _ => {
                         /* sign & encrypt */
-                        let mut op_clocks: libc::clock_t;
-                        let mut start: libc::clock_t = clock();
+                        let op_clocks: libc::clock_t;
+                        let start: libc::clock_t = clock();
                         if private_key.is_null() {
                             encrypted = rpgp::rpgp_encrypt_bytes_to_keys(
                                 plain_text as *const uint8_t,
@@ -484,8 +481,7 @@ pub unsafe fn dc_pgp_pk_encrypt(
                             2132137392766895896 => {}
                             _ => {
                                 /* convert message to armored bytes and return values */
-                                let mut armored: *mut rpgp::cvec =
-                                    rpgp::rpgp_msg_to_armored(encrypted);
+                                let armored: *mut rpgp::cvec = rpgp::rpgp_msg_to_armored(encrypted);
                                 if !(0 != dc_pgp_handle_rpgp_error(context)) {
                                     *ret_ctext = rpgp::rpgp_cvec_data(armored) as *mut libc::c_void;
                                     *ret_ctext_bytes = rpgp::rpgp_cvec_len(armored) as size_t;
@@ -516,15 +512,15 @@ pub unsafe fn dc_pgp_pk_encrypt(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_pgp_pk_decrypt(
-    mut context: &dc_context_t,
-    mut ctext: *const libc::c_void,
-    mut ctext_bytes: size_t,
-    mut raw_private_keys_for_decryption: *const dc_keyring_t,
-    mut raw_public_keys_for_validation: *const dc_keyring_t,
-    mut use_armor: libc::c_int,
-    mut ret_plain: *mut *mut libc::c_void,
-    mut ret_plain_bytes: *mut size_t,
-    mut ret_signature_fingerprints: *mut dc_hash_t,
+    context: &dc_context_t,
+    ctext: *const libc::c_void,
+    ctext_bytes: size_t,
+    raw_private_keys_for_decryption: *const dc_keyring_t,
+    raw_public_keys_for_validation: *const dc_keyring_t,
+    use_armor: libc::c_int,
+    ret_plain: *mut *mut libc::c_void,
+    ret_plain_bytes: *mut size_t,
+    ret_signature_fingerprints: *mut dc_hash_t,
 ) -> libc::c_int {
     let mut current_block: u64;
     let mut i: libc::c_int;
@@ -622,7 +618,7 @@ pub unsafe fn dc_pgp_pk_decrypt(
                                 public_keys_len as usize,
                             );
                             if !(0 != dc_pgp_handle_rpgp_error(context)) {
-                                let mut decrypted_bytes: *mut rpgp::cvec =
+                                let decrypted_bytes: *mut rpgp::cvec =
                                     rpgp::rpgp_msg_to_bytes((*decrypted).message_ptr);
                                 if !(0 != dc_pgp_handle_rpgp_error(context)) {
                                     *ret_plain_bytes =
@@ -632,10 +628,9 @@ pub unsafe fn dc_pgp_pk_decrypt(
                                     free(decrypted_bytes as *mut libc::c_void);
                                     if !ret_signature_fingerprints.is_null() {
                                         let mut j: uint32_t = 0i32 as uint32_t;
-                                        let mut len: uint32_t =
-                                            (*decrypted).valid_ids_len as uint32_t;
+                                        let len: uint32_t = (*decrypted).valid_ids_len as uint32_t;
                                         while j < len {
-                                            let mut fingerprint_hex: *mut libc::c_char =
+                                            let fingerprint_hex: *mut libc::c_char =
                                                 *(*decrypted).valid_ids_ptr.offset(j as isize);
                                             if !fingerprint_hex.is_null() {
                                                 dc_hash_insert(
@@ -681,11 +676,11 @@ pub unsafe fn dc_pgp_pk_decrypt(
 /* symm. encryption */
 // TODO should return bool /rtn
 pub unsafe fn dc_pgp_symm_encrypt(
-    mut context: &dc_context_t,
-    mut passphrase: *const libc::c_char,
-    mut plain: *const libc::c_void,
-    mut plain_bytes: size_t,
-    mut ret_ctext_armored: *mut *mut libc::c_char,
+    context: &dc_context_t,
+    passphrase: *const libc::c_char,
+    plain: *const libc::c_void,
+    plain_bytes: size_t,
+    ret_ctext_armored: *mut *mut libc::c_char,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut decrypted: *mut rpgp::Message = 0 as *mut rpgp::Message;
@@ -715,16 +710,16 @@ pub unsafe fn dc_pgp_symm_encrypt(
 
 // TODO should return bool /rtn
 pub unsafe fn dc_pgp_symm_decrypt(
-    mut context: &dc_context_t,
-    mut passphrase: *const libc::c_char,
-    mut ctext: *const libc::c_void,
-    mut ctext_bytes: size_t,
-    mut ret_plain_text: *mut *mut libc::c_void,
-    mut ret_plain_bytes: *mut size_t,
+    context: &dc_context_t,
+    passphrase: *const libc::c_char,
+    ctext: *const libc::c_void,
+    ctext_bytes: size_t,
+    ret_plain_text: *mut *mut libc::c_void,
+    ret_plain_bytes: *mut size_t,
 ) -> libc::c_int {
-    let mut decrypted_bytes: *mut rpgp::cvec;
+    let decrypted_bytes: *mut rpgp::cvec;
     let mut success: libc::c_int = 0i32;
-    let mut encrypted: *mut rpgp::Message;
+    let encrypted: *mut rpgp::Message;
     let mut decrypted: *mut rpgp::Message = 0 as *mut rpgp::Message;
     encrypted = rpgp::rpgp_msg_from_bytes(ctext as *const uint8_t, ctext_bytes as usize);
     if !(0 != dc_pgp_handle_rpgp_error(context)) {
diff --git a/src/dc_qr.rs b/src/dc_qr.rs
index 9bd5ec2ca..520794a4a 100644
--- a/src/dc_qr.rs
+++ b/src/dc_qr.rs
@@ -21,10 +21,7 @@ use crate::x::*;
 // text1=text
 // text1=URL
 // text1=error string
-pub unsafe fn dc_check_qr(
-    mut context: &dc_context_t,
-    mut qr: *const libc::c_char,
-) -> *mut dc_lot_t {
+pub unsafe fn dc_check_qr(context: &dc_context_t, qr: *const libc::c_char) -> *mut dc_lot_t {
     let mut current_block: u64;
     let mut payload: *mut libc::c_char = 0 as *mut libc::c_char;
     // must be normalized, if set
@@ -34,7 +31,7 @@ pub unsafe fn dc_check_qr(
     let mut name: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut invitenumber: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut auth: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+    let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
     let mut qr_parsed: *mut dc_lot_t = dc_lot_new();
     let mut chat_id: uint32_t = 0i32 as uint32_t;
     let mut device_msg: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -64,7 +61,7 @@ pub unsafe fn dc_check_qr(
             if !fragment.is_null() {
                 *fragment = 0i32 as libc::c_char;
                 fragment = fragment.offset(1isize);
-                let mut param: *mut dc_param_t = dc_param_new();
+                let param: *mut dc_param_t = dc_param_new();
                 dc_param_set_urlencoded(param, fragment);
                 addr = dc_param_get(param, 'a' as i32, 0 as *const libc::c_char);
                 if !addr.is_null() {
@@ -99,7 +96,7 @@ pub unsafe fn dc_check_qr(
             payload = dc_strdup(
                 &*qr.offset(strlen(b"mailto:\x00" as *const u8 as *const libc::c_char) as isize),
             );
-            let mut query: *mut libc::c_char = strchr(payload, '?' as i32);
+            let query: *mut libc::c_char = strchr(payload, '?' as i32);
             if !query.is_null() {
                 *query = 0i32 as libc::c_char
             }
@@ -114,7 +111,7 @@ pub unsafe fn dc_check_qr(
             payload = dc_strdup(
                 &*qr.offset(strlen(b"SMTP:\x00" as *const u8 as *const libc::c_char) as isize),
             );
-            let mut colon: *mut libc::c_char = strchr(payload, ':' as i32);
+            let colon: *mut libc::c_char = strchr(payload, ':' as i32);
             if !colon.is_null() {
                 *colon = 0i32 as libc::c_char
             }
@@ -128,11 +125,10 @@ pub unsafe fn dc_check_qr(
         {
             /* scheme: `MATMSG:TO:addr...;SUB:subject...;BODY:body...;` - there may or may not be linebreaks after the fields */
             /* does not work when the text `TO:` is used in subject/body _and_ TO: is not the first field. we ignore this case. */
-            let mut to: *mut libc::c_char =
-                strstr(qr, b"TO:\x00" as *const u8 as *const libc::c_char);
+            let to: *mut libc::c_char = strstr(qr, b"TO:\x00" as *const u8 as *const libc::c_char);
             if !to.is_null() {
                 addr = dc_strdup(&mut *to.offset(3isize));
-                let mut semicolon: *mut libc::c_char = strchr(addr, ';' as i32);
+                let semicolon: *mut libc::c_char = strchr(addr, ';' as i32);
                 if !semicolon.is_null() {
                     *semicolon = 0i32 as libc::c_char
                 }
@@ -150,10 +146,10 @@ pub unsafe fn dc_check_qr(
                 strlen(b"BEGIN:VCARD\x00" as *const u8 as *const libc::c_char),
             ) == 0i32
             {
-                let mut lines: *mut carray = dc_split_into_lines(qr);
+                let lines: *mut carray = dc_split_into_lines(qr);
                 let mut i: libc::c_int = 0i32;
                 while (i as libc::c_uint) < carray_count(lines) {
-                    let mut key: *mut libc::c_char =
+                    let key: *mut libc::c_char =
                         carray_get(lines, i as libc::c_uint) as *mut libc::c_char;
                     dc_trim(key);
                     let mut value: *mut libc::c_char = strchr(key, ':' as i32);
diff --git a/src/dc_receive_imf.rs b/src/dc_receive_imf.rs
index 3f5884e56..2bd82c03e 100644
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -42,7 +42,7 @@ pub unsafe fn dc_receive_imf(
     /* the function returns the number of created messages in the database */
     let mut incoming: libc::c_int = 1i32;
     let mut incoming_origin: libc::c_int = 0i32;
-    let mut to_ids: *mut dc_array_t;
+    let to_ids: *mut dc_array_t;
     let mut to_self: libc::c_int = 0i32;
     let mut from_id: uint32_t = 0i32 as uint32_t;
     let mut from_id_blocked: libc::c_int = 0i32;
@@ -62,13 +62,13 @@ pub unsafe fn dc_receive_imf(
     let mut sort_timestamp: time_t = -1i32 as time_t;
     let mut sent_timestamp: time_t = -1i32 as time_t;
     let mut rcvd_timestamp: time_t = -1i32 as time_t;
-    let mut mime_parser: *mut dc_mimeparser_t = dc_mimeparser_new(context.get_blobdir(), context);
+    let mime_parser: *mut dc_mimeparser_t = dc_mimeparser_new(context.get_blobdir(), context);
     let mut field: *const mailimf_field;
     let mut mime_in_reply_to: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut mime_references: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut created_db_entries: *mut carray = carray_new(16i32 as libc::c_uint);
+    let created_db_entries: *mut carray = carray_new(16i32 as libc::c_uint);
     let mut create_event_to_send = Some(Event::MSGS_CHANGED);
-    let mut rr_event_to_send: *mut carray = carray_new(16i32 as libc::c_uint);
+    let rr_event_to_send: *mut carray = carray_new(16i32 as libc::c_uint);
     let mut txt_raw: *mut libc::c_char = 0 as *mut libc::c_char;
     dc_log_info(
         context,
@@ -107,7 +107,7 @@ pub unsafe fn dc_receive_imf(
                 b"Date\x00" as *const u8 as *const libc::c_char,
             );
             if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_ORIG_DATE as libc::c_int {
-                let mut orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
+                let orig_date: *mut mailimf_orig_date = (*field).fld_data.fld_orig_date;
                 if !orig_date.is_null() {
                     sent_timestamp = dc_timestamp_from_date((*orig_date).dt_date_time)
                 }
@@ -117,10 +117,10 @@ pub unsafe fn dc_receive_imf(
                 b"From\x00" as *const u8 as *const libc::c_char,
             );
             if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_FROM as libc::c_int {
-                let mut fld_from: *mut mailimf_from = (*field).fld_data.fld_from;
+                let fld_from: *mut mailimf_from = (*field).fld_data.fld_from;
                 if !fld_from.is_null() {
                     let mut check_self: libc::c_int = 0;
-                    let mut from_list: *mut dc_array_t = dc_array_new(16i32 as size_t);
+                    let from_list: *mut dc_array_t = dc_array_new(16i32 as size_t);
                     dc_add_or_lookup_contacts_by_mailbox_list(
                         context,
                         (*fld_from).frm_mb_list,
@@ -146,7 +146,7 @@ pub unsafe fn dc_receive_imf(
                 b"To\x00" as *const u8 as *const libc::c_char,
             );
             if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_TO as libc::c_int {
-                let mut fld_to: *mut mailimf_to = (*field).fld_data.fld_to;
+                let fld_to: *mut mailimf_to = (*field).fld_data.fld_to;
                 if !fld_to.is_null() {
                     dc_add_or_lookup_contacts_by_address_list(
                         context,
@@ -169,7 +169,7 @@ pub unsafe fn dc_receive_imf(
                     b"Cc\x00" as *const u8 as *const libc::c_char,
                 );
                 if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_CC as libc::c_int {
-                    let mut fld_cc: *mut mailimf_cc = (*field).fld_data.fld_cc;
+                    let fld_cc: *mut mailimf_cc = (*field).fld_data.fld_cc;
                     if !fld_cc.is_null() {
                         dc_add_or_lookup_contacts_by_address_list(
                             context,
@@ -192,8 +192,7 @@ pub unsafe fn dc_receive_imf(
                 );
                 if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_MESSAGE_ID as libc::c_int
                 {
-                    let mut fld_message_id: *mut mailimf_message_id =
-                        (*field).fld_data.fld_message_id;
+                    let fld_message_id: *mut mailimf_message_id = (*field).fld_data.fld_message_id;
                     if !fld_message_id.is_null() {
                         rfc724_mid = dc_strdup((*fld_message_id).mid_value)
                     }
@@ -255,7 +254,7 @@ pub unsafe fn dc_receive_imf(
                             by checking the state before the message body is downloaded */
                             let mut allow_creation: libc::c_int = 1i32;
                             if msgrmsg == 0i32 {
-                                let mut show_emails: libc::c_int = dc_sqlite3_get_config_int(
+                                let show_emails: libc::c_int = dc_sqlite3_get_config_int(
                                     context,
                                     &context.sql.clone().read().unwrap(),
                                     b"show_emails\x00" as *const u8 as *const libc::c_char,
@@ -284,7 +283,7 @@ pub unsafe fn dc_receive_imf(
                                     msgrmsg = 1i32;
                                     chat_id = 0i32 as uint32_t;
                                     allow_creation = 1i32;
-                                    let mut handshake: libc::c_int = dc_handle_securejoin_handshake(
+                                    let handshake: libc::c_int = dc_handle_securejoin_handshake(
                                         context,
                                         mime_parser,
                                         from_id,
@@ -304,8 +303,7 @@ pub unsafe fn dc_receive_imf(
                                     &mut test_normal_chat_id_blocked,
                                 );
                                 if chat_id == 0i32 as libc::c_uint {
-                                    let mut create_blocked: libc::c_int = if 0
-                                        != test_normal_chat_id
+                                    let create_blocked: libc::c_int = if 0 != test_normal_chat_id
                                         && test_normal_chat_id_blocked == 0i32
                                         || incoming_origin >= 0x7fffffffi32
                                     {
@@ -341,7 +339,7 @@ pub unsafe fn dc_receive_imf(
                                     }
                                 }
                                 if chat_id == 0i32 as libc::c_uint {
-                                    let mut create_blocked_0: libc::c_int =
+                                    let create_blocked_0: libc::c_int =
                                         if incoming_origin >= 0x7fffffffi32 || from_id == to_id {
                                             0i32
                                         } else {
@@ -409,7 +407,7 @@ pub unsafe fn dc_receive_imf(
                                         }
                                     }
                                     if chat_id == 0i32 as libc::c_uint && 0 != allow_creation {
-                                        let mut create_blocked_1: libc::c_int = if 0 != msgrmsg
+                                        let create_blocked_1: libc::c_int = if 0 != msgrmsg
                                             && 0 == dc_is_contact_blocked(context, to_id)
                                         {
                                             0i32
@@ -468,7 +466,7 @@ pub unsafe fn dc_receive_imf(
                             dc_unarchive_chat(context, chat_id);
                             // if the mime-headers should be saved, find out its size
                             // (the mime-header ends with an empty line)
-                            let mut save_mime_headers: libc::c_int = dc_sqlite3_get_config_int(
+                            let save_mime_headers: libc::c_int = dc_sqlite3_get_config_int(
                                 context,
                                 &context.sql.clone().read().unwrap(),
                                 b"save_mime_headers\x00" as *const u8 as *const libc::c_char,
@@ -507,7 +505,7 @@ pub unsafe fn dc_receive_imf(
                             if !field.is_null()
                                 && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int
                             {
-                                let mut fld_in_reply_to: *mut mailimf_in_reply_to =
+                                let fld_in_reply_to: *mut mailimf_in_reply_to =
                                     (*field).fld_data.fld_in_reply_to;
                                 if !fld_in_reply_to.is_null() {
                                     mime_in_reply_to = dc_str_from_clist(
@@ -523,7 +521,7 @@ pub unsafe fn dc_receive_imf(
                             if !field.is_null()
                                 && (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int
                             {
-                                let mut fld_references: *mut mailimf_references =
+                                let fld_references: *mut mailimf_references =
                                     (*field).fld_data.fld_references;
                                 if !fld_references.is_null() {
                                     mime_references = dc_str_from_clist(
@@ -546,7 +544,7 @@ pub unsafe fn dc_receive_imf(
                                     current_block = 2756754640271984560;
                                     break;
                                 }
-                                let mut part: *mut dc_mimepart_t =
+                                let part: *mut dc_mimepart_t =
                                     carray_get((*mime_parser).parts, i as libc::c_uint)
                                         as *mut dc_mimepart_t;
                                 if !(0 != (*part).is_meta) {
@@ -713,7 +711,7 @@ pub unsafe fn dc_receive_imf(
                 16282941964262048061 => {}
                 _ => {
                     if carray_count((*mime_parser).reports) > 0i32 as libc::c_uint {
-                        let mut mdns_enabled: libc::c_int = dc_sqlite3_get_config_int(
+                        let mdns_enabled: libc::c_int = dc_sqlite3_get_config_int(
                             context,
                             &context.sql.clone().read().unwrap(),
                             b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
@@ -723,14 +721,13 @@ pub unsafe fn dc_receive_imf(
                         i = 0i32 as size_t;
                         while i < icnt {
                             let mut mdn_consumed: libc::c_int = 0i32;
-                            let mut report_root: *mut mailmime =
+                            let report_root: *mut mailmime =
                                 carray_get((*mime_parser).reports, i as libc::c_uint)
                                     as *mut mailmime;
-                            let mut report_type: *mut mailmime_parameter =
-                                mailmime_find_ct_parameter(
-                                    report_root,
-                                    b"report-type\x00" as *const u8 as *const libc::c_char,
-                                );
+                            let report_type: *mut mailmime_parameter = mailmime_find_ct_parameter(
+                                report_root,
+                                b"report-type\x00" as *const u8 as *const libc::c_char,
+                            );
                             if !(report_root.is_null()
                                 || report_type.is_null()
                                 || (*report_type).pa_value.is_null())
@@ -744,11 +741,22 @@ pub unsafe fn dc_receive_imf(
                                         >= 2i32
                                 {
                                     if 0 != mdns_enabled {
-                                        let mut report_data: *mut mailmime =
-                                            (if !if !(*(*report_root)
-                                                .mm_data
-                                                .mm_multipart
-                                                .mm_mp_list)
+                                        let report_data: *mut mailmime = (if !if !(*(*report_root)
+                                            .mm_data
+                                            .mm_multipart
+                                            .mm_mp_list)
+                                            .first
+                                            .is_null()
+                                        {
+                                            (*(*(*report_root).mm_data.mm_multipart.mm_mp_list)
+                                                .first)
+                                                .next
+                                        } else {
+                                            0 as *mut clistcell
+                                        }
+                                        .is_null()
+                                        {
+                                            (*if !(*(*report_root).mm_data.mm_multipart.mm_mp_list)
                                                 .first
                                                 .is_null()
                                             {
@@ -757,30 +765,12 @@ pub unsafe fn dc_receive_imf(
                                                     .next
                                             } else {
                                                 0 as *mut clistcell
-                                            }
-                                            .is_null()
-                                            {
-                                                (*if !(*(*report_root)
-                                                    .mm_data
-                                                    .mm_multipart
-                                                    .mm_mp_list)
-                                                    .first
-                                                    .is_null()
-                                                {
-                                                    (*(*(*report_root)
-                                                        .mm_data
-                                                        .mm_multipart
-                                                        .mm_mp_list)
-                                                        .first)
-                                                        .next
-                                                } else {
-                                                    0 as *mut clistcell
-                                                })
-                                                .data
-                                            } else {
-                                                0 as *mut libc::c_void
                                             })
-                                                as *mut mailmime;
+                                            .data
+                                        } else {
+                                            0 as *mut libc::c_void
+                                        })
+                                            as *mut mailmime;
                                         if !report_data.is_null()
                                             && (*(*(*report_data).mm_content_type).ct_type).tp_type
                                                 == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int
@@ -817,10 +807,10 @@ pub unsafe fn dc_receive_imf(
                                                 ) == MAIL_NO_ERROR as libc::c_int
                                                     && !report_parsed.is_null()
                                                 {
-                                                    let mut report_fields: *mut mailimf_fields =
+                                                    let report_fields: *mut mailimf_fields =
                                                         mailmime_find_mailimf_fields(report_parsed);
                                                     if !report_fields.is_null() {
-                                                        let mut of_disposition:
+                                                        let  of_disposition:
                                                                 *mut mailimf_optional_field =
                                                             mailimf_find_optional_field(report_fields,
                                                                                         b"Disposition\x00"
@@ -828,7 +818,7 @@ pub unsafe fn dc_receive_imf(
                                                                                             *const u8
                                                                                             as
                                                                                             *const libc::c_char);
-                                                        let mut of_org_msgid:
+                                                        let  of_org_msgid:
                                                                 *mut mailimf_optional_field =
                                                             mailimf_find_optional_field(report_fields,
                                                                                         b"Original-Message-ID\x00"
@@ -901,7 +891,7 @@ pub unsafe fn dc_receive_imf(
                                     }
                                     if 0 != (*mime_parser).is_send_by_messenger || 0 != mdn_consumed
                                     {
-                                        let mut param: *mut dc_param_t = dc_param_new();
+                                        let param: *mut dc_param_t = dc_param_new();
                                         dc_param_set(param, 'Z' as i32, server_folder);
                                         dc_param_set_int(param, 'z' as i32, server_uid as int32_t);
                                         if 0 != (*mime_parser).is_send_by_messenger
@@ -930,7 +920,7 @@ pub unsafe fn dc_receive_imf(
                         if !(*mime_parser).message_kml.is_null()
                             && chat_id > DC_CHAT_ID_LAST_SPECIAL as libc::c_uint
                         {
-                            let mut newest_location_id: uint32_t = dc_save_locations(
+                            let newest_location_id: uint32_t = dc_save_locations(
                                 context,
                                 chat_id,
                                 from_id,
@@ -1006,7 +996,7 @@ pub unsafe fn dc_receive_imf(
     if !created_db_entries.is_null() {
         if let Some(create_event_to_send) = create_event_to_send {
             let mut i_0: size_t = 0;
-            let mut icnt_0: size_t = carray_count(created_db_entries) as size_t;
+            let icnt_0: size_t = carray_count(created_db_entries) as size_t;
             while i_0 < icnt_0 {
                 ((*context).cb)(
                     context,
@@ -1022,7 +1012,7 @@ pub unsafe fn dc_receive_imf(
     }
     if !rr_event_to_send.is_null() {
         let mut i_1: size_t;
-        let mut icnt_1: size_t = carray_count(rr_event_to_send) as size_t;
+        let icnt_1: size_t = carray_count(rr_event_to_send) as size_t;
         i_1 = 0i32 as size_t;
         while i_1 < icnt_1 {
             ((*context).cb)(
@@ -1042,14 +1032,14 @@ pub unsafe fn dc_receive_imf(
  * Misc. Tools
  ******************************************************************************/
 unsafe fn calc_timestamps(
-    mut context: &dc_context_t,
-    mut chat_id: uint32_t,
-    mut from_id: uint32_t,
-    mut message_timestamp: time_t,
-    mut is_fresh_msg: libc::c_int,
-    mut sort_timestamp: *mut time_t,
-    mut sent_timestamp: *mut time_t,
-    mut rcvd_timestamp: *mut time_t,
+    context: &dc_context_t,
+    chat_id: uint32_t,
+    from_id: uint32_t,
+    message_timestamp: time_t,
+    is_fresh_msg: libc::c_int,
+    sort_timestamp: *mut time_t,
+    sent_timestamp: *mut time_t,
+    rcvd_timestamp: *mut time_t,
 ) {
     *rcvd_timestamp = time(0 as *mut time_t);
     *sent_timestamp = message_timestamp;
@@ -1058,7 +1048,7 @@ unsafe fn calc_timestamps(
     }
     *sort_timestamp = message_timestamp;
     if 0 != is_fresh_msg {
-        let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+        let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
             context,
             &context.sql.clone().read().unwrap(),
             b"SELECT MAX(timestamp) FROM msgs WHERE chat_id=? and from_id!=? AND timestamp>=?\x00"
@@ -1068,7 +1058,7 @@ unsafe fn calc_timestamps(
         sqlite3_bind_int(stmt, 2i32, from_id as libc::c_int);
         sqlite3_bind_int64(stmt, 3i32, *sort_timestamp as sqlite3_int64);
         if sqlite3_step(stmt) == 100i32 {
-            let mut last_msg_time: time_t = sqlite3_column_int64(stmt, 0i32) as time_t;
+            let last_msg_time: time_t = sqlite3_column_int64(stmt, 0i32) as time_t;
             if last_msg_time > 0i32 as libc::c_long {
                 if *sort_timestamp <= last_msg_time {
                     *sort_timestamp = last_msg_time + 1i32 as libc::c_long
@@ -1094,16 +1084,16 @@ which tries to create or find out the chat_id by:
 So when the function returns, the caller has the group id matching the current
 state of the group. */
 unsafe fn create_or_lookup_group(
-    mut context: &dc_context_t,
+    context: &dc_context_t,
     mut mime_parser: *mut dc_mimeparser_t,
-    mut allow_creation: libc::c_int,
-    mut create_blocked: libc::c_int,
-    mut from_id: int32_t,
-    mut to_ids: *const dc_array_t,
-    mut ret_chat_id: *mut uint32_t,
-    mut ret_chat_id_blocked: *mut libc::c_int,
+    allow_creation: libc::c_int,
+    create_blocked: libc::c_int,
+    from_id: int32_t,
+    to_ids: *const dc_array_t,
+    ret_chat_id: *mut uint32_t,
+    ret_chat_id_blocked: *mut libc::c_int,
 ) {
-    let mut group_explicitly_left: libc::c_int;
+    let group_explicitly_left: libc::c_int;
     let mut current_block: u64;
     let mut chat_id: uint32_t = 0i32 as uint32_t;
     let mut chat_id_blocked: libc::c_int = 0i32;
@@ -1112,7 +1102,7 @@ unsafe fn create_or_lookup_group(
     let mut grpname: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut stmt: *mut sqlite3_stmt;
     let mut i: libc::c_int;
-    let mut to_ids_cnt: libc::c_int = dc_array_get_cnt(to_ids) as libc::c_int;
+    let to_ids_cnt: libc::c_int = dc_array_get_cnt(to_ids) as libc::c_int;
     let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut recreate_member_list: libc::c_int = 0i32;
     let mut send_EVENT_CHAT_MODIFIED: libc::c_int = 0i32;
@@ -1150,7 +1140,7 @@ unsafe fn create_or_lookup_group(
             b"Message-ID\x00" as *const u8 as *const libc::c_char,
         );
         if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_MESSAGE_ID as libc::c_int {
-            let mut fld_message_id: *mut mailimf_message_id = (*field).fld_data.fld_message_id;
+            let fld_message_id: *mut mailimf_message_id = (*field).fld_data.fld_message_id;
             if !fld_message_id.is_null() {
                 grpid = dc_extract_grpid_from_rfc724_mid((*fld_message_id).mid_value)
             }
@@ -1161,8 +1151,7 @@ unsafe fn create_or_lookup_group(
                 b"In-Reply-To\x00" as *const u8 as *const libc::c_char,
             );
             if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
-                let mut fld_in_reply_to: *mut mailimf_in_reply_to =
-                    (*field).fld_data.fld_in_reply_to;
+                let fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
                 if !fld_in_reply_to.is_null() {
                     grpid = dc_extract_grpid_from_rfc724_mid_list((*fld_in_reply_to).mid_list)
                 }
@@ -1174,8 +1163,7 @@ unsafe fn create_or_lookup_group(
                 );
                 if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int
                 {
-                    let mut fld_references: *mut mailimf_references =
-                        (*field).fld_data.fld_references;
+                    let fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
                     if !fld_references.is_null() {
                         grpid = dc_extract_grpid_from_rfc724_mid_list((*fld_references).mid_list)
                     }
@@ -1220,7 +1208,7 @@ unsafe fn create_or_lookup_group(
             if !optional_field.is_null() {
                 X_MrRemoveFromGrp = (*optional_field).fld_value;
                 (*mime_parser).is_system_message = 5i32;
-                let mut left_group: libc::c_int =
+                let left_group: libc::c_int =
                     (dc_lookup_contact_id_by_addr(context, X_MrRemoveFromGrp)
                         == from_id as libc::c_uint) as libc::c_int;
                 better_msg = dc_stock_system_msg(
@@ -1428,7 +1416,7 @@ unsafe fn create_or_lookup_group(
                             } else {
                                 let mut i_0: libc::c_int = 0i32;
                                 while (i_0 as libc::c_uint) < carray_count((*mime_parser).parts) {
-                                    let mut part: *mut dc_mimepart_t =
+                                    let part: *mut dc_mimepart_t =
                                         carray_get((*mime_parser).parts, i_0 as libc::c_uint)
                                             as *mut dc_mimepart_t;
                                     if (*part).type_0 == 20i32 {
@@ -1443,7 +1431,7 @@ unsafe fn create_or_lookup_group(
                                 }
                             }
                             if 0 != ok {
-                                let mut chat: *mut dc_chat_t = dc_chat_new(context);
+                                let chat: *mut dc_chat_t = dc_chat_new(context);
                                 dc_log_info(
                                     context,
                                     0i32,
@@ -1464,7 +1452,7 @@ unsafe fn create_or_lookup_group(
                             }
                         }
                         if 0 != recreate_member_list {
-                            let mut skip: *const libc::c_char = if !X_MrRemoveFromGrp.is_null() {
+                            let skip: *const libc::c_char = if !X_MrRemoveFromGrp.is_null() {
                                 X_MrRemoveFromGrp
                             } else {
                                 0 as *mut libc::c_char
@@ -1500,7 +1488,7 @@ unsafe fn create_or_lookup_group(
                             }
                             i = 0i32;
                             while i < to_ids_cnt {
-                                let mut to_id: uint32_t = dc_array_get_id(to_ids, i as size_t);
+                                let to_id: uint32_t = dc_array_get_id(to_ids, i as size_t);
                                 if dc_addr_equals_contact(context, self_addr, to_id) == 0i32
                                     && (skip.is_null()
                                         || dc_addr_equals_contact(context, skip, to_id) == 0i32)
@@ -1523,7 +1511,7 @@ unsafe fn create_or_lookup_group(
                         /* check the number of receivers -
                         the only critical situation is if the user hits "Reply" instead of "Reply all" in a non-messenger-client */
                         if to_ids_cnt == 1i32 && (*mime_parser).is_send_by_messenger == 0i32 {
-                            let mut is_contact_cnt: libc::c_int =
+                            let is_contact_cnt: libc::c_int =
                                 dc_get_chat_contact_cnt(context, chat_id);
                             if is_contact_cnt > 3i32 {
                                 /* to_ids_cnt==1 may be "From: A, To: B, SELF" as SELF is not counted in to_ids_cnt. So everything up to 3 is no error. */
@@ -1562,16 +1550,16 @@ unsafe fn create_or_lookup_group(
  * Handle groups for received messages
  ******************************************************************************/
 unsafe fn create_or_lookup_adhoc_group(
-    mut context: &dc_context_t,
-    mut mime_parser: *mut dc_mimeparser_t,
-    mut allow_creation: libc::c_int,
-    mut create_blocked: libc::c_int,
-    mut from_id: int32_t,
-    mut to_ids: *const dc_array_t,
-    mut ret_chat_id: *mut uint32_t,
-    mut ret_chat_id_blocked: *mut libc::c_int,
+    context: &dc_context_t,
+    mime_parser: *mut dc_mimeparser_t,
+    allow_creation: libc::c_int,
+    create_blocked: libc::c_int,
+    from_id: int32_t,
+    to_ids: *const dc_array_t,
+    ret_chat_id: *mut uint32_t,
+    ret_chat_id_blocked: *mut libc::c_int,
 ) {
-    let mut current_block: u64;
+    let current_block: u64;
     /* if we're here, no grpid was found, check there is an existing ad-hoc
     group matching the to-list or if we can create one */
     let mut member_ids: *mut dc_array_t = 0 as *mut dc_array_t;
@@ -1676,14 +1664,14 @@ unsafe fn create_or_lookup_adhoc_group(
     };
 }
 unsafe fn create_group_record(
-    mut context: &dc_context_t,
-    mut grpid: *const libc::c_char,
-    mut grpname: *const libc::c_char,
-    mut create_blocked: libc::c_int,
-    mut create_verified: libc::c_int,
+    context: &dc_context_t,
+    grpid: *const libc::c_char,
+    grpname: *const libc::c_char,
+    create_blocked: libc::c_int,
+    create_verified: libc::c_int,
 ) -> uint32_t {
     let mut chat_id: uint32_t = 0i32 as uint32_t;
-    let mut stmt: *mut sqlite3_stmt;
+    let stmt: *mut sqlite3_stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -1711,8 +1699,8 @@ unsafe fn create_group_record(
     return chat_id;
 }
 unsafe fn create_adhoc_grp_id(
-    mut context: &dc_context_t,
-    mut member_ids: *mut dc_array_t,
+    context: &dc_context_t,
+    member_ids: *mut dc_array_t,
 ) -> *mut libc::c_char {
     /* algorithm:
     - sort normalized, lowercased, e-mail addresses alphabetically
@@ -1720,14 +1708,14 @@ unsafe fn create_adhoc_grp_id(
     - sha-256 this string (without possibly terminating null-characters)
     - encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f])
      */
-    let mut member_addrs: *mut dc_array_t = dc_array_new(23i32 as size_t);
-    let mut member_ids_str: *mut libc::c_char =
+    let member_addrs: *mut dc_array_t = dc_array_new(23i32 as size_t);
+    let member_ids_str: *mut libc::c_char =
         dc_array_get_string(member_ids, b",\x00" as *const u8 as *const libc::c_char);
-    let mut stmt: *mut sqlite3_stmt;
-    let mut q3: *mut libc::c_char;
+    let stmt: *mut sqlite3_stmt;
+    let q3: *mut libc::c_char;
     let mut addr: *mut libc::c_char;
     let mut i: libc::c_int;
-    let mut iCnt: libc::c_int;
+    let iCnt: libc::c_int;
     let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut member_cs: dc_strbuilder_t = dc_strbuilder_t {
         buf: 0 as *mut libc::c_char,
@@ -1769,7 +1757,7 @@ unsafe fn create_adhoc_grp_id(
         i += 1
     }
     /* make sha-256 from the string */
-    let mut binary_hash: *mut crate::pgp::cvec = pgp::rpgp_hash_sha256(
+    let binary_hash: *mut crate::pgp::cvec = pgp::rpgp_hash_sha256(
         member_cs.buf as *const uint8_t,
         strlen(member_cs.buf) as usize,
     );
@@ -1797,23 +1785,23 @@ unsafe fn create_adhoc_grp_id(
     return ret;
 }
 unsafe fn search_chat_ids_by_contact_ids(
-    mut context: &dc_context_t,
-    mut unsorted_contact_ids: *const dc_array_t,
+    context: &dc_context_t,
+    unsorted_contact_ids: *const dc_array_t,
 ) -> *mut dc_array_t {
     /* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
-    let mut contact_ids: *mut dc_array_t = dc_array_new(23i32 as size_t);
+    let contact_ids: *mut dc_array_t = dc_array_new(23i32 as size_t);
     let mut contact_ids_str: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut chat_ids: *mut dc_array_t = dc_array_new(23i32 as size_t);
+    let chat_ids: *mut dc_array_t = dc_array_new(23i32 as size_t);
 
     /* copy array, remove duplicates and SELF, sort by ID */
     let mut i: libc::c_int;
-    let mut iCnt: libc::c_int = dc_array_get_cnt(unsorted_contact_ids) as libc::c_int;
+    let iCnt: libc::c_int = dc_array_get_cnt(unsorted_contact_ids) as libc::c_int;
     if !(iCnt <= 0i32) {
         i = 0i32;
         while i < iCnt {
-            let mut curr_id: uint32_t = dc_array_get_id(unsorted_contact_ids, i as size_t);
+            let curr_id: uint32_t = dc_array_get_id(unsorted_contact_ids, i as size_t);
             if curr_id != 1i32 as libc::c_uint
                 && 0 == dc_array_search_id(contact_ids, curr_id, 0 as *mut size_t)
             {
@@ -1834,8 +1822,8 @@ unsafe fn search_chat_ids_by_contact_ids(
             let mut matches = 0;
             let mut mismatches = 0;
             while sqlite3_step(stmt) == 100 {
-                let mut chat_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
-                let mut contact_id: uint32_t = sqlite3_column_int(stmt, 1i32) as uint32_t;
+                let chat_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
+                let contact_id: uint32_t = sqlite3_column_int(stmt, 1i32) as uint32_t;
                 if chat_id != last_chat_id {
                     if matches == dc_array_get_cnt(contact_ids)
                         && mismatches == 0i32 as libc::c_uint
@@ -1865,16 +1853,16 @@ unsafe fn search_chat_ids_by_contact_ids(
     return chat_ids;
 }
 unsafe fn check_verified_properties(
-    mut context: &dc_context_t,
-    mut mimeparser: *mut dc_mimeparser_t,
-    mut from_id: uint32_t,
-    mut to_ids: *const dc_array_t,
-    mut failure_reason: *mut *mut libc::c_char,
+    context: &dc_context_t,
+    mimeparser: *mut dc_mimeparser_t,
+    from_id: uint32_t,
+    to_ids: *const dc_array_t,
+    failure_reason: *mut *mut libc::c_char,
 ) -> libc::c_int {
     let mut current_block: u64;
     let mut everythings_okay: libc::c_int = 0i32;
-    let mut contact: *mut dc_contact_t = dc_contact_new(context);
-    let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+    let contact: *mut dc_contact_t = dc_contact_new(context);
+    let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
     let mut to_ids_str: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -1943,7 +1931,7 @@ unsafe fn check_verified_properties(
                         current_block = 2604890879466389055;
                         break;
                     }
-                    let mut to_addr: *const libc::c_char =
+                    let to_addr: *const libc::c_char =
                         sqlite3_column_text(stmt, 0i32) as *const libc::c_char;
                     let mut is_verified: libc::c_int = sqlite3_column_int(stmt, 1i32);
                     if !dc_hash_find(
@@ -1992,7 +1980,7 @@ unsafe fn check_verified_properties(
                     if !(0 == is_verified) {
                         continue;
                     }
-                    let mut err: *mut libc::c_char = dc_mprintf(
+                    let err: *mut libc::c_char = dc_mprintf(
                         b"%s is not a member of this verified group.\x00" as *const u8
                             as *const libc::c_char,
                         to_addr,
@@ -2020,10 +2008,7 @@ unsafe fn check_verified_properties(
     sqlite3_free(q3 as *mut libc::c_void);
     return everythings_okay;
 }
-unsafe fn set_better_msg(
-    mut mime_parser: *mut dc_mimeparser_t,
-    mut better_msg: *mut *mut libc::c_char,
-) {
+unsafe fn set_better_msg(mime_parser: *mut dc_mimeparser_t, better_msg: *mut *mut libc::c_char) {
     if !(*better_msg).is_null() && carray_count((*mime_parser).parts) > 0i32 as libc::c_uint {
         let mut part: *mut dc_mimepart_t =
             carray_get((*mime_parser).parts, 0i32 as libc::c_uint) as *mut dc_mimepart_t;
@@ -2035,12 +2020,12 @@ unsafe fn set_better_msg(
     };
 }
 unsafe fn dc_is_reply_to_known_message(
-    mut context: &dc_context_t,
-    mut mime_parser: *mut dc_mimeparser_t,
+    context: &dc_context_t,
+    mime_parser: *mut dc_mimeparser_t,
 ) -> libc::c_int {
     /* check if the message is a reply to a known message; the replies are identified by the Message-ID from
     `In-Reply-To`/`References:` (to support non-Delta-Clients) or from `Chat-Predecessor:` (Delta clients, see comment in dc_chat.c) */
-    let mut optional_field: *mut mailimf_optional_field;
+    let optional_field: *mut mailimf_optional_field;
     optional_field = dc_mimeparser_lookup_optional_field(
         mime_parser,
         b"Chat-Predecessor\x00" as *const u8 as *const libc::c_char,
@@ -2056,7 +2041,7 @@ unsafe fn dc_is_reply_to_known_message(
         b"In-Reply-To\x00" as *const u8 as *const libc::c_char,
     );
     if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
-        let mut fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
+        let fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
         if !fld_in_reply_to.is_null() {
             if 0 != is_known_rfc724_mid_in_list(
                 context,
@@ -2071,7 +2056,7 @@ unsafe fn dc_is_reply_to_known_message(
         b"References\x00" as *const u8 as *const libc::c_char,
     );
     if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int {
-        let mut fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
+        let fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
         if !fld_references.is_null() {
             if 0 != is_known_rfc724_mid_in_list(
                 context,
@@ -2084,8 +2069,8 @@ unsafe fn dc_is_reply_to_known_message(
     return 0i32;
 }
 unsafe fn is_known_rfc724_mid_in_list(
-    mut context: &dc_context_t,
-    mut mid_list: *const clist,
+    context: &dc_context_t,
+    mid_list: *const clist,
 ) -> libc::c_int {
     if !mid_list.is_null() {
         let mut cur: *mut clistiter;
@@ -2114,12 +2099,12 @@ unsafe fn is_known_rfc724_mid_in_list(
  * Check if a message is a reply to a known message (messenger or non-messenger)
  ******************************************************************************/
 unsafe fn is_known_rfc724_mid(
-    mut context: &dc_context_t,
-    mut rfc724_mid: *const libc::c_char,
+    context: &dc_context_t,
+    rfc724_mid: *const libc::c_char,
 ) -> libc::c_int {
     let mut is_known: libc::c_int = 0i32;
     if !rfc724_mid.is_null() {
-        let mut stmt: *mut sqlite3_stmt =
+        let  stmt: *mut sqlite3_stmt =
             dc_sqlite3_prepare(context, &context.sql.clone().read().unwrap(),
                                b"SELECT m.id FROM msgs m  LEFT JOIN chats c ON m.chat_id=c.id  WHERE m.rfc724_mid=?  AND m.chat_id>9 AND c.blocked=0;\x00"
                                    as *const u8 as *const libc::c_char);
@@ -2132,8 +2117,8 @@ unsafe fn is_known_rfc724_mid(
     return is_known;
 }
 unsafe fn dc_is_reply_to_messenger_message(
-    mut context: &dc_context_t,
-    mut mime_parser: *mut dc_mimeparser_t,
+    context: &dc_context_t,
+    mime_parser: *mut dc_mimeparser_t,
 ) -> libc::c_int {
     /* function checks, if the message defined by mime_parser references a message send by us from Delta Chat.
     This is similar to is_reply_to_known_message() but
@@ -2146,7 +2131,7 @@ unsafe fn dc_is_reply_to_messenger_message(
         b"In-Reply-To\x00" as *const u8 as *const libc::c_char,
     );
     if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
-        let mut fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
+        let fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
         if !fld_in_reply_to.is_null() {
             if 0 != is_msgrmsg_rfc724_mid_in_list(
                 context,
@@ -2161,7 +2146,7 @@ unsafe fn dc_is_reply_to_messenger_message(
         b"References\x00" as *const u8 as *const libc::c_char,
     );
     if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int {
-        let mut fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
+        let fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
         if !fld_references.is_null() {
             if 0 != is_msgrmsg_rfc724_mid_in_list(
                 context,
@@ -2174,8 +2159,8 @@ unsafe fn dc_is_reply_to_messenger_message(
     return 0i32;
 }
 unsafe fn is_msgrmsg_rfc724_mid_in_list(
-    mut context: &dc_context_t,
-    mut mid_list: *const clist,
+    context: &dc_context_t,
+    mid_list: *const clist,
 ) -> libc::c_int {
     if !mid_list.is_null() {
         let mut cur: *mut clistiter = (*mid_list).first;
@@ -2203,12 +2188,12 @@ unsafe fn is_msgrmsg_rfc724_mid_in_list(
  * Check if a message is a reply to any messenger message
  ******************************************************************************/
 unsafe fn is_msgrmsg_rfc724_mid(
-    mut context: &dc_context_t,
-    mut rfc724_mid: *const libc::c_char,
+    context: &dc_context_t,
+    rfc724_mid: *const libc::c_char,
 ) -> libc::c_int {
     let mut is_msgrmsg: libc::c_int = 0i32;
     if !rfc724_mid.is_null() {
-        let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+        let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
             context,
             &context.sql.clone().read().unwrap(),
             b"SELECT id FROM msgs  WHERE rfc724_mid=?  AND msgrmsg!=0  AND chat_id>9;\x00"
@@ -2223,25 +2208,25 @@ unsafe fn is_msgrmsg_rfc724_mid(
     return is_msgrmsg;
 }
 unsafe fn dc_add_or_lookup_contacts_by_address_list(
-    mut context: &dc_context_t,
-    mut adr_list: *const mailimf_address_list,
-    mut origin: libc::c_int,
-    mut ids: *mut dc_array_t,
-    mut check_self: *mut libc::c_int,
+    context: &dc_context_t,
+    adr_list: *const mailimf_address_list,
+    origin: libc::c_int,
+    ids: *mut dc_array_t,
+    check_self: *mut libc::c_int,
 ) {
     if adr_list.is_null() {
         return;
     }
     let mut cur: *mut clistiter = (*(*adr_list).ad_list).first;
     while !cur.is_null() {
-        let mut adr: *mut mailimf_address = (if !cur.is_null() {
+        let adr: *mut mailimf_address = (if !cur.is_null() {
             (*cur).data
         } else {
             0 as *mut libc::c_void
         }) as *mut mailimf_address;
         if !adr.is_null() {
             if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
-                let mut mb: *mut mailimf_mailbox = (*adr).ad_data.ad_mailbox;
+                let mb: *mut mailimf_mailbox = (*adr).ad_data.ad_mailbox;
                 if !mb.is_null() {
                     add_or_lookup_contact_by_addr(
                         context,
@@ -2253,7 +2238,7 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list(
                     );
                 }
             } else if (*adr).ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
-                let mut group: *mut mailimf_group = (*adr).ad_data.ad_group;
+                let group: *mut mailimf_group = (*adr).ad_data.ad_group;
                 if !group.is_null() && !(*group).grp_mb_list.is_null() {
                     dc_add_or_lookup_contacts_by_mailbox_list(
                         context,
@@ -2273,18 +2258,18 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list(
     }
 }
 unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
-    mut context: &dc_context_t,
-    mut mb_list: *const mailimf_mailbox_list,
-    mut origin: libc::c_int,
-    mut ids: *mut dc_array_t,
-    mut check_self: *mut libc::c_int,
+    context: &dc_context_t,
+    mb_list: *const mailimf_mailbox_list,
+    origin: libc::c_int,
+    ids: *mut dc_array_t,
+    check_self: *mut libc::c_int,
 ) {
     if mb_list.is_null() {
         return;
     }
     let mut cur: *mut clistiter = (*(*mb_list).mb_list).first;
     while !cur.is_null() {
-        let mut mb: *mut mailimf_mailbox = (if !cur.is_null() {
+        let mb: *mut mailimf_mailbox = (if !cur.is_null() {
             (*cur).data
         } else {
             0 as *mut libc::c_void
@@ -2310,11 +2295,11 @@ unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
  * Add contacts to database on receiving messages
  ******************************************************************************/
 unsafe fn add_or_lookup_contact_by_addr(
-    mut context: &dc_context_t,
-    mut display_name_enc: *const libc::c_char,
-    mut addr_spec: *const libc::c_char,
-    mut origin: libc::c_int,
-    mut ids: *mut dc_array_t,
+    context: &dc_context_t,
+    display_name_enc: *const libc::c_char,
+    addr_spec: *const libc::c_char,
+    origin: libc::c_int,
+    ids: *mut dc_array_t,
     mut check_self: *mut libc::c_int,
 ) {
     /* is addr_spec equal to SELF? */
@@ -2326,7 +2311,7 @@ unsafe fn add_or_lookup_contact_by_addr(
         return;
     }
     *check_self = 0i32;
-    let mut self_addr: *mut libc::c_char = dc_sqlite3_get_config(
+    let self_addr: *mut libc::c_char = dc_sqlite3_get_config(
         context,
         &context.sql.clone().read().unwrap(),
         b"configured_addr\x00" as *const u8 as *const libc::c_char,
@@ -2346,7 +2331,7 @@ unsafe fn add_or_lookup_contact_by_addr(
         dc_normalize_name(display_name_dec);
     }
     /*can be NULL*/
-    let mut row_id: uint32_t = dc_add_or_lookup_contact(
+    let row_id: uint32_t = dc_add_or_lookup_contact(
         context,
         display_name_dec,
         addr_spec,
diff --git a/src/dc_saxparser.rs b/src/dc_saxparser.rs
index a78994fdc..31897b536 100644
--- a/src/dc_saxparser.rs
+++ b/src/dc_saxparser.rs
@@ -22,7 +22,7 @@ pub type dc_saxparser_starttag_cb_t = Option<
 
 pub unsafe extern "C" fn dc_saxparser_init(
     mut saxparser: *mut dc_saxparser_t,
-    mut userdata: *mut libc::c_void,
+    userdata: *mut libc::c_void,
 ) {
     (*saxparser).userdata = userdata;
     (*saxparser).starttag_cb = Some(def_starttag_cb);
@@ -47,8 +47,8 @@ unsafe fn def_starttag_cb(
 
 pub unsafe fn dc_saxparser_set_tag_handler(
     mut saxparser: *mut dc_saxparser_t,
-    mut starttag_cb: dc_saxparser_starttag_cb_t,
-    mut endtag_cb: dc_saxparser_endtag_cb_t,
+    starttag_cb: dc_saxparser_starttag_cb_t,
+    endtag_cb: dc_saxparser_endtag_cb_t,
 ) {
     if saxparser.is_null() {
         return;
@@ -67,7 +67,7 @@ pub unsafe fn dc_saxparser_set_tag_handler(
 
 pub unsafe fn dc_saxparser_set_text_handler(
     mut saxparser: *mut dc_saxparser_t,
-    mut text_cb: dc_saxparser_text_cb_t,
+    text_cb: dc_saxparser_text_cb_t,
 ) {
     if saxparser.is_null() {
         return;
@@ -79,13 +79,10 @@ pub unsafe fn dc_saxparser_set_text_handler(
     };
 }
 
-pub unsafe fn dc_saxparser_parse(
-    mut saxparser: *mut dc_saxparser_t,
-    mut buf_start__: *const libc::c_char,
-) {
-    let mut current_block: u64;
+pub unsafe fn dc_saxparser_parse(saxparser: *mut dc_saxparser_t, buf_start__: *const libc::c_char) {
+    let current_block: u64;
     let mut bak: libc::c_char;
-    let mut buf_start: *mut libc::c_char;
+    let buf_start: *mut libc::c_char;
     let mut last_text_start: *mut libc::c_char;
     let mut p: *mut libc::c_char;
     /* attributes per tag - a fixed border here is a security feature, not a limit */
@@ -123,7 +120,7 @@ pub unsafe fn dc_saxparser_parse(
             } else if strncmp(p, b"![CDATA[\x00" as *const u8 as *const libc::c_char, 8) == 0i32 {
                 /* process <![CDATA[ ... ]]> text
                  **************************************************************/
-                let mut text_beg: *mut libc::c_char = p.offset(8isize);
+                let text_beg: *mut libc::c_char = p.offset(8isize);
                 p = strstr(p, b"]]>\x00" as *const u8 as *const libc::c_char);
                 if !p.is_null() {
                     call_text_cb(
@@ -183,7 +180,7 @@ pub unsafe fn dc_saxparser_parse(
                     p = p.offset(
                         strspn(p, b"\t\r\n \x00" as *const u8 as *const libc::c_char) as isize,
                     );
-                    let mut beg_tag_name: *mut libc::c_char = p;
+                    let beg_tag_name: *mut libc::c_char = p;
                     p = p.offset(
                         strcspn(p, b"\t\r\n />\x00" as *const u8 as *const libc::c_char) as isize,
                     );
@@ -199,12 +196,12 @@ pub unsafe fn dc_saxparser_parse(
                     }
                 } else {
                     do_free_attr(attr.as_mut_ptr(), free_attr.as_mut_ptr());
-                    let mut beg_tag_name_0: *mut libc::c_char = p;
+                    let beg_tag_name_0: *mut libc::c_char = p;
                     p = p.offset(
                         strcspn(p, b"\t\r\n />\x00" as *const u8 as *const libc::c_char) as isize,
                     );
                     if p != beg_tag_name_0 {
-                        let mut after_tag_name: *mut libc::c_char = p;
+                        let after_tag_name: *mut libc::c_char = p;
                         let mut attr_index: libc::c_int = 0i32;
                         while 0 != libc::isspace(*p as libc::c_int) {
                             p = p.offset(1isize)
@@ -213,9 +210,9 @@ pub unsafe fn dc_saxparser_parse(
                             && *p as libc::c_int != '/' as i32
                             && *p as libc::c_int != '>' as i32
                         {
-                            let mut beg_attr_name: *mut libc::c_char = p;
+                            let beg_attr_name: *mut libc::c_char = p;
                             let mut beg_attr_value: *mut libc::c_char = 0 as *mut libc::c_char;
-                            let mut beg_attr_value_new: *mut libc::c_char;
+                            let beg_attr_value_new: *mut libc::c_char;
                             if '=' as i32 == *beg_attr_name as libc::c_int {
                                 p = p.offset(1isize)
                             } else {
@@ -224,7 +221,7 @@ pub unsafe fn dc_saxparser_parse(
                                     b"\t\r\n =/>\x00" as *const u8 as *const libc::c_char,
                                 ) as isize);
                                 if p != beg_attr_name {
-                                    let mut after_attr_name: *mut libc::c_char = p;
+                                    let after_attr_name: *mut libc::c_char = p;
                                     p = p.offset(strspn(
                                         p,
                                         b"\t\r\n \x00" as *const u8 as *const libc::c_char,
@@ -235,7 +232,7 @@ pub unsafe fn dc_saxparser_parse(
                                             b"\t\r\n =\x00" as *const u8 as *const libc::c_char,
                                         )
                                             as isize);
-                                        let mut quote: libc::c_char = *p;
+                                        let quote: libc::c_char = *p;
                                         if quote as libc::c_int == '\"' as i32
                                             || quote as libc::c_int == '\'' as i32
                                         {
@@ -264,8 +261,7 @@ pub unsafe fn dc_saxparser_parse(
                                                 as isize);
                                             bak = *p;
                                             *p = '\u{0}' as i32 as libc::c_char;
-                                            let mut temp: *mut libc::c_char =
-                                                dc_strdup(beg_attr_value);
+                                            let temp: *mut libc::c_char = dc_strdup(beg_attr_value);
                                             beg_attr_value_new =
                                                 xml_decode(temp, ' ' as i32 as libc::c_char);
                                             if beg_attr_value_new != temp {
@@ -307,7 +303,7 @@ pub unsafe fn dc_saxparser_parse(
                                 }
                             }
                         }
-                        let mut bak_0: libc::c_char = *after_tag_name;
+                        let bak_0: libc::c_char = *after_tag_name;
                         *after_tag_name = 0i32 as libc::c_char;
                         dc_strlower_in_place(beg_tag_name_0);
                         (*saxparser).starttag_cb.expect("non-null function pointer")(
@@ -358,7 +354,7 @@ pub unsafe fn dc_saxparser_parse(
     free(buf_start as *mut libc::c_void);
 }
 
-unsafe fn do_free_attr(mut attr: *mut *mut libc::c_char, mut free_attr: *mut libc::c_int) {
+unsafe fn do_free_attr(attr: *mut *mut libc::c_char, free_attr: *mut libc::c_int) {
     /* "attr" are key/value pairs; the function frees the data if the corresponding bit in "free_attr" is set.
     (we need this as we try to use the strings from the "main" document instead of allocating small strings) */
     let mut i: libc::c_int = 0i32;
@@ -380,14 +376,14 @@ unsafe fn do_free_attr(mut attr: *mut *mut libc::c_char, mut free_attr: *mut lib
 }
 
 unsafe fn call_text_cb(
-    mut saxparser: *mut dc_saxparser_t,
-    mut text: *mut libc::c_char,
-    mut len: size_t,
-    mut type_0: libc::c_char,
+    saxparser: *mut dc_saxparser_t,
+    text: *mut libc::c_char,
+    len: size_t,
+    type_0: libc::c_char,
 ) {
     if !text.is_null() && 0 != len {
-        let mut bak: libc::c_char = *text.offset(len as isize);
-        let mut text_new: *mut libc::c_char;
+        let bak: libc::c_char = *text.offset(len as isize);
+        let text_new: *mut libc::c_char;
         *text.offset(len as isize) = '\u{0}' as i32 as libc::c_char;
         text_new = xml_decode(text, type_0);
         (*saxparser).text_cb.expect("non-null function pointer")(
@@ -421,10 +417,10 @@ Returns s, or if the decoded string is longer than s, returns a malloced string
 that must be freed.
 Function based upon ezxml_decode() from the "ezxml" parser which is
 Copyright 2004-2006 Aaron Voisine <aaron@voisine.org> */
-unsafe fn xml_decode(mut s: *mut libc::c_char, mut type_0: libc::c_char) -> *mut libc::c_char {
+unsafe fn xml_decode(mut s: *mut libc::c_char, type_0: libc::c_char) -> *mut libc::c_char {
     let mut e: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut r: *mut libc::c_char = s;
-    let mut original_buf: *const libc::c_char = s;
+    let original_buf: *const libc::c_char = s;
     let mut b;
     let mut c: isize;
     let mut d: isize;
@@ -517,14 +513,14 @@ unsafe fn xml_decode(mut s: *mut libc::c_char, mut type_0: libc::c_char) -> *mut
                     d = s.wrapping_offset_from(r) as isize;
                     l = (d + c).wrapping_add(strlen(e) as isize);
                     if r == original_buf as *mut libc::c_char {
-                        let mut new_ret = malloc(l as usize) as *mut libc::c_char;
+                        let new_ret = malloc(l as usize) as *mut libc::c_char;
                         if new_ret.is_null() {
                             return r;
                         }
                         strcpy(new_ret, r);
                         r = new_ret
                     } else {
-                        let mut new_ret_0: *mut libc::c_char =
+                        let new_ret_0: *mut libc::c_char =
                             realloc(r as *mut libc::c_void, l as usize) as *mut libc::c_char;
                         if new_ret_0.is_null() {
                             return r;
@@ -1085,8 +1081,8 @@ static mut s_ent: [*const libc::c_char; 508] = [
 ];
 
 pub unsafe fn dc_attr_find(
-    mut attr: *mut *mut libc::c_char,
-    mut key: *const libc::c_char,
+    attr: *mut *mut libc::c_char,
+    key: *const libc::c_char,
 ) -> *const libc::c_char {
     if !attr.is_null() && !key.is_null() {
         let mut i: libc::c_int = 0i32;
diff --git a/src/dc_securejoin.rs b/src/dc_securejoin.rs
index b9e243cca..dd28440ee 100644
--- a/src/dc_securejoin.rs
+++ b/src/dc_securejoin.rs
@@ -25,16 +25,16 @@ use crate::types::*;
 use crate::x::*;
 
 pub unsafe fn dc_get_securejoin_qr(
-    mut context: &dc_context_t,
-    mut group_chat_id: uint32_t,
+    context: &dc_context_t,
+    group_chat_id: uint32_t,
 ) -> *mut libc::c_char {
-    let mut current_block: u64;
+    let current_block: u64;
     /* =========================================================
     ====             Alice - the inviter side            ====
     ====   Step 1 in "Setup verified contact" protocol   ====
     ========================================================= */
     let mut qr: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut self_addr: *mut libc::c_char;
+    let self_addr: *mut libc::c_char;
     let mut self_addr_urlencoded: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut self_name: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut self_name_urlencoded: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -147,9 +147,9 @@ pub unsafe fn dc_get_securejoin_qr(
     };
 }
 
-unsafe fn get_self_fingerprint(mut context: &dc_context_t) -> *mut libc::c_char {
-    let mut self_addr: *mut libc::c_char;
-    let mut self_key: *mut dc_key_t = dc_key_new();
+unsafe fn get_self_fingerprint(context: &dc_context_t) -> *mut libc::c_char {
+    let self_addr: *mut libc::c_char;
+    let self_key: *mut dc_key_t = dc_key_new();
     let mut fingerprint: *mut libc::c_char = 0 as *mut libc::c_char;
     self_addr = dc_sqlite3_get_config(
         context,
@@ -174,16 +174,13 @@ unsafe fn get_self_fingerprint(mut context: &dc_context_t) -> *mut libc::c_char
     fingerprint
 }
 
-pub unsafe fn dc_join_securejoin(
-    mut context: &dc_context_t,
-    mut qr: *const libc::c_char,
-) -> uint32_t {
+pub unsafe fn dc_join_securejoin(context: &dc_context_t, qr: *const libc::c_char) -> uint32_t {
     /* ==========================================================
     ====             Bob - the joiner's side             =====
     ====   Step 2 in "Setup verified contact" protocol   =====
     ========================================================== */
     let mut ret_chat_id: libc::c_int = 0i32;
-    let mut ongoing_allocated: libc::c_int;
+    let ongoing_allocated: libc::c_int;
     let mut contact_chat_id: uint32_t = 0i32 as uint32_t;
     let mut join_vg: libc::c_int = 0i32;
     let mut qr_scan: *mut dc_lot_t = 0 as *mut dc_lot_t;
@@ -236,7 +233,7 @@ pub unsafe fn dc_join_securejoin(
                         chat_id_2_contact_id(context, contact_chat_id) as uintptr_t,
                         400i32 as uintptr_t,
                     );
-                    let mut own_fingerprint: *mut libc::c_char = get_self_fingerprint(context);
+                    let own_fingerprint: *mut libc::c_char = get_self_fingerprint(context);
                     send_handshake_msg(
                         context,
                         contact_chat_id,
@@ -308,12 +305,12 @@ pub unsafe fn dc_join_securejoin(
 }
 
 unsafe fn send_handshake_msg(
-    mut context: &dc_context_t,
-    mut contact_chat_id: uint32_t,
-    mut step: *const libc::c_char,
-    mut param2: *const libc::c_char,
-    mut fingerprint: *const libc::c_char,
-    mut grpid: *const libc::c_char,
+    context: &dc_context_t,
+    contact_chat_id: uint32_t,
+    step: *const libc::c_char,
+    param2: *const libc::c_char,
+    fingerprint: *const libc::c_char,
+    grpid: *const libc::c_char,
 ) {
     let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
     (*msg).type_0 = 10i32;
@@ -344,12 +341,9 @@ unsafe fn send_handshake_msg(
     dc_msg_unref(msg);
 }
 
-unsafe fn chat_id_2_contact_id(
-    mut context: &dc_context_t,
-    mut contact_chat_id: uint32_t,
-) -> uint32_t {
+unsafe fn chat_id_2_contact_id(context: &dc_context_t, contact_chat_id: uint32_t) -> uint32_t {
     let mut contact_id: uint32_t = 0i32 as uint32_t;
-    let mut contacts: *mut dc_array_t = dc_get_chat_contacts(context, contact_chat_id);
+    let contacts: *mut dc_array_t = dc_get_chat_contacts(context, contact_chat_id);
     if !(dc_array_get_cnt(contacts) != 1) {
         contact_id = dc_array_get_id(contacts, 0i32 as size_t)
     }
@@ -359,14 +353,14 @@ unsafe fn chat_id_2_contact_id(
 }
 
 unsafe fn fingerprint_equals_sender(
-    mut context: &dc_context_t,
-    mut fingerprint: *const libc::c_char,
-    mut contact_chat_id: uint32_t,
+    context: &dc_context_t,
+    fingerprint: *const libc::c_char,
+    contact_chat_id: uint32_t,
 ) -> libc::c_int {
     let mut fingerprint_equal: libc::c_int = 0i32;
-    let mut contacts: *mut dc_array_t = dc_get_chat_contacts(context, contact_chat_id);
-    let mut contact: *mut dc_contact_t = dc_contact_new(context);
-    let mut peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
+    let contacts: *mut dc_array_t = dc_get_chat_contacts(context, contact_chat_id);
+    let contact: *mut dc_contact_t = dc_contact_new(context);
+    let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
     let mut fingerprint_normalized: *mut libc::c_char = 0 as *mut libc::c_char;
     if !(dc_array_get_cnt(contacts) != 1) {
         if !(0
@@ -401,8 +395,8 @@ pub unsafe fn dc_handle_securejoin_handshake(
     contact_id: uint32_t,
 ) -> libc::c_int {
     let mut current_block: u64;
-    let mut step: *const libc::c_char;
-    let mut join_vg: libc::c_int;
+    let step: *const libc::c_char;
+    let join_vg: libc::c_int;
     let mut scanned_fingerprint_of_alice: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut auth: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut own_fingerprint: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -448,7 +442,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
                 // it just ensures, we have Bobs key now. If we do _not_ have the key because eg. MitM has removed it,
                 // send_message() will fail with the error "End-to-end-encryption unavailable unexpectedly.", so, there is no additional check needed here.
                 // verify that the `Secure-Join-Invitenumber:`-header matches invitenumber written to the QR code
-                let mut invitenumber: *const libc::c_char;
+                let invitenumber: *const libc::c_char;
                 invitenumber = lookup_field(
                     mimeparser,
                     b"Secure-Join-Invitenumber\x00" as *const u8 as *const libc::c_char,
@@ -595,7 +589,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
                 ====  Step 6 in "Out-of-band verified groups" protocol  ====
                 ============================================================ */
                 // verify that Secure-Join-Fingerprint:-header matches the fingerprint of Bob
-                let mut fingerprint: *const libc::c_char;
+                let fingerprint: *const libc::c_char;
                 fingerprint = lookup_field(
                     mimeparser,
                     b"Secure-Join-Fingerprint\x00" as *const u8 as *const libc::c_char,
@@ -629,7 +623,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
                         b"Fingerprint verified.\x00" as *const u8 as *const libc::c_char,
                     );
                     // verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code
-                    let mut auth_0: *const libc::c_char;
+                    let auth_0: *const libc::c_char;
                     auth_0 = lookup_field(
                         mimeparser,
                         b"Secure-Join-Auth\x00" as *const u8 as *const libc::c_char,
@@ -681,7 +675,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
                                 mimeparser,
                                 b"Secure-Join-Group\x00" as *const u8 as *const libc::c_char,
                             ));
-                            let mut group_chat_id: uint32_t = dc_get_chat_id_by_grpid(
+                            let group_chat_id: uint32_t = dc_get_chat_id_by_grpid(
                                 context,
                                 grpid,
                                 0 as *mut libc::c_int,
@@ -912,10 +906,10 @@ unsafe fn end_bobs_joining(context: &dc_context_t, status: libc::c_int) {
     dc_stop_ongoing_process(context);
 }
 
-unsafe fn secure_connection_established(mut context: &dc_context_t, mut contact_chat_id: uint32_t) {
-    let mut contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id);
-    let mut contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
-    let mut msg: *mut libc::c_char = dc_stock_str_repl_string(
+unsafe fn secure_connection_established(context: &dc_context_t, contact_chat_id: uint32_t) {
+    let contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id);
+    let contact: *mut dc_contact_t = dc_get_contact(context, contact_id);
+    let msg: *mut libc::c_char = dc_stock_str_repl_string(
         context,
         35i32,
         if !contact.is_null() {
@@ -936,11 +930,11 @@ unsafe fn secure_connection_established(mut context: &dc_context_t, mut contact_
 }
 
 unsafe fn lookup_field(
-    mut mimeparser: *mut dc_mimeparser_t,
-    mut key: *const libc::c_char,
+    mimeparser: *mut dc_mimeparser_t,
+    key: *const libc::c_char,
 ) -> *const libc::c_char {
     let mut value: *const libc::c_char = 0 as *const libc::c_char;
-    let mut field: *mut mailimf_field = dc_mimeparser_lookup_field(mimeparser, key);
+    let field: *mut mailimf_field = dc_mimeparser_lookup_field(mimeparser, key);
     if field.is_null()
         || (*field).fld_type != MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int
         || (*field).fld_data.fld_optional_field.is_null()
@@ -960,9 +954,9 @@ unsafe fn could_not_establish_secure_connection(
     contact_chat_id: uint32_t,
     details: *const libc::c_char,
 ) {
-    let mut contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id);
-    let mut contact = dc_get_contact(context, contact_id);
-    let mut msg: *mut libc::c_char = dc_stock_str_repl_string(
+    let contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id);
+    let contact = dc_get_contact(context, contact_id);
+    let msg: *mut libc::c_char = dc_stock_str_repl_string(
         context,
         36i32,
         if !contact.is_null() {
@@ -1014,8 +1008,8 @@ unsafe fn mark_peer_as_verified(
 
 // TODO should return bool
 unsafe fn encrypted_and_signed(
-    mut mimeparser: *mut dc_mimeparser_t,
-    mut expected_fingerprint: *const libc::c_char,
+    mimeparser: *mut dc_mimeparser_t,
+    expected_fingerprint: *const libc::c_char,
 ) -> libc::c_int {
     if 0 == (*(*mimeparser).e2ee_helper).encrypted {
         dc_log_warning(
@@ -1061,12 +1055,9 @@ unsafe fn encrypted_and_signed(
     1
 }
 
-pub unsafe fn dc_handle_degrade_event(
-    mut context: &dc_context_t,
-    mut peerstate: *mut dc_apeerstate_t,
-) {
-    let mut stmt;
-    let mut contact_id: uint32_t;
+pub unsafe fn dc_handle_degrade_event(context: &dc_context_t, peerstate: *mut dc_apeerstate_t) {
+    let stmt;
+    let contact_id: uint32_t;
     let mut contact_chat_id: uint32_t = 0i32 as uint32_t;
     if !peerstate.is_null() {
         // - we do not issue an warning for DC_DE_ENCRYPTION_PAUSED as this is quite normal
@@ -1092,7 +1083,7 @@ pub unsafe fn dc_handle_degrade_event(
                     &mut contact_chat_id,
                     0 as *mut libc::c_int,
                 );
-                let mut msg: *mut libc::c_char =
+                let msg: *mut libc::c_char =
                     dc_stock_str_repl_string(context, 37i32, (*peerstate).addr);
                 dc_add_device_msg(context, contact_chat_id, msg);
                 free(msg as *mut libc::c_void);
diff --git a/src/dc_simplify.rs b/src/dc_simplify.rs
index 340b9ccd1..e70b91f05 100644
--- a/src/dc_simplify.rs
+++ b/src/dc_simplify.rs
@@ -13,7 +13,7 @@ pub struct dc_simplify_t {
 }
 
 pub unsafe fn dc_simplify_new() -> *mut dc_simplify_t {
-    let mut simplify: *mut dc_simplify_t;
+    let simplify: *mut dc_simplify_t;
     simplify = calloc(1, ::std::mem::size_of::<dc_simplify_t>()) as *mut dc_simplify_t;
     if simplify.is_null() {
         exit(31i32);
@@ -22,7 +22,7 @@ pub unsafe fn dc_simplify_new() -> *mut dc_simplify_t {
     simplify
 }
 
-pub unsafe fn dc_simplify_unref(mut simplify: *mut dc_simplify_t) {
+pub unsafe fn dc_simplify_unref(simplify: *mut dc_simplify_t) {
     if simplify.is_null() {
         return;
     }
@@ -34,10 +34,10 @@ lineends etc.
 The data returned from Simplify() must be free()'d when no longer used, private */
 pub unsafe fn dc_simplify_simplify(
     mut simplify: *mut dc_simplify_t,
-    mut in_unterminated: *const libc::c_char,
-    mut in_bytes: libc::c_int,
-    mut is_html: libc::c_int,
-    mut is_msgrmsg: libc::c_int,
+    in_unterminated: *const libc::c_char,
+    in_bytes: libc::c_int,
+    is_html: libc::c_int,
+    is_msgrmsg: libc::c_int,
 ) -> *mut libc::c_char {
     /* create a copy of the given buffer */
     let mut out: *mut libc::c_char;
@@ -78,8 +78,8 @@ pub unsafe fn dc_simplify_simplify(
  ******************************************************************************/
 unsafe fn dc_simplify_simplify_plain_text(
     mut simplify: *mut dc_simplify_t,
-    mut buf_terminated: *const libc::c_char,
-    mut is_msgrmsg: libc::c_int,
+    buf_terminated: *const libc::c_char,
+    is_msgrmsg: libc::c_int,
 ) -> *mut libc::c_char {
     /* This function ...
     ... removes all text after the line `-- ` (footer mark)
@@ -87,7 +87,7 @@ unsafe fn dc_simplify_simplify_plain_text(
         these are all lines starting with the character `>`
     ... remove a non-empty line before the removed quote (contains sth. like "On 2.9.2016, Bjoern wrote:" in different formats and lanugages) */
     /* split the given buffer into lines */
-    let mut lines: *mut carray = dc_split_into_lines(buf_terminated);
+    let lines: *mut carray = dc_split_into_lines(buf_terminated);
     let mut l: libc::c_int;
     let mut l_first: libc::c_int = 0i32;
     /* if l_last is -1, there are no lines */
@@ -119,11 +119,11 @@ unsafe fn dc_simplify_simplify_plain_text(
         }
     }
     if l_last - l_first + 1i32 >= 3i32 {
-        let mut line0: *mut libc::c_char =
+        let line0: *mut libc::c_char =
             carray_get(lines, l_first as libc::c_uint) as *mut libc::c_char;
-        let mut line1: *mut libc::c_char =
+        let line1: *mut libc::c_char =
             carray_get(lines, (l_first + 1i32) as libc::c_uint) as *mut libc::c_char;
-        let mut line2: *mut libc::c_char =
+        let line2: *mut libc::c_char =
             carray_get(lines, (l_first + 2i32) as libc::c_uint) as *mut libc::c_char;
         if strcmp(
             line0,
@@ -257,7 +257,7 @@ unsafe fn dc_simplify_simplify_plain_text(
  * Tools
  ******************************************************************************/
 // TODO should return bool /rtn
-unsafe fn is_empty_line(mut buf: *const libc::c_char) -> libc::c_int {
+unsafe fn is_empty_line(buf: *const libc::c_char) -> libc::c_int {
     /* force unsigned - otherwise the `> ' '` comparison will fail */
     let mut p1: *const libc::c_uchar = buf as *const libc::c_uchar;
     while 0 != *p1 {
@@ -271,12 +271,12 @@ unsafe fn is_empty_line(mut buf: *const libc::c_char) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-unsafe fn is_quoted_headline(mut buf: *const libc::c_char) -> libc::c_int {
+unsafe fn is_quoted_headline(buf: *const libc::c_char) -> libc::c_int {
     /* This function may be called for the line _directly_ before a quote.
     The function checks if the line contains sth. like "On 01.02.2016, xy@z wrote:" in various languages.
     - Currently, we simply check if the last character is a ':'.
     - Checking for the existance of an email address may fail (headlines may show the user's name instead of the address) */
-    let mut buf_len: libc::c_int = strlen(buf) as libc::c_int;
+    let buf_len: libc::c_int = strlen(buf) as libc::c_int;
     if buf_len > 80i32 {
         return 0i32;
     }
@@ -288,7 +288,7 @@ unsafe fn is_quoted_headline(mut buf: *const libc::c_char) -> libc::c_int {
 }
 
 // TODO should return bool /rtn
-unsafe fn is_plain_quote(mut buf: *const libc::c_char) -> libc::c_int {
+unsafe fn is_plain_quote(buf: *const libc::c_char) -> libc::c_int {
     if *buf.offset(0isize) as libc::c_int == '>' as i32 {
         return 1i32;
     }
diff --git a/src/dc_smtp.rs b/src/dc_smtp.rs
index 06293b104..eb963c6ab 100644
--- a/src/dc_smtp.rs
+++ b/src/dc_smtp.rs
@@ -105,7 +105,7 @@ impl Smtp {
         let creds = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
             // oauth2
 
-            let mut access_token =
+            let access_token =
                 unsafe { dc_get_oauth2_access_token(context, lp.addr, lp.send_pw, 0i32) };
             if access_token.is_null() {
                 return 0;
diff --git a/src/dc_sqlite3.rs b/src/dc_sqlite3.rs
index c13ba0a97..054bc85a4 100644
--- a/src/dc_sqlite3.rs
+++ b/src/dc_sqlite3.rs
@@ -907,15 +907,14 @@ pub unsafe fn dc_sqlite3_open(
                         }
 
                         if 0 != recalc_fingerprints {
-                            let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
+                            let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
                                 context,
                                 sql,
                                 b"SELECT addr FROM acpeerstates;\x00" as *const u8
                                     as *const libc::c_char,
                             );
                             while sqlite3_step(stmt) == 100 {
-                                let mut peerstate: *mut dc_apeerstate_t =
-                                    dc_apeerstate_new(context);
+                                let peerstate: *mut dc_apeerstate_t = dc_apeerstate_new(context);
                                 if 0 != dc_apeerstate_load_by_addr(
                                     peerstate,
                                     sql,
@@ -929,7 +928,7 @@ pub unsafe fn dc_sqlite3_open(
                             sqlite3_finalize(stmt);
                         }
                         if 0 != update_file_paths {
-                            let mut repl_from: *mut libc::c_char = dc_sqlite3_get_config(
+                            let repl_from: *mut libc::c_char = dc_sqlite3_get_config(
                                 context,
                                 sql,
                                 b"backup_for\x00" as *const u8 as *const libc::c_char,
@@ -1132,7 +1131,7 @@ pub unsafe extern "C" fn dc_sqlite3_log_error(
     msg_format: *const libc::c_char,
     va: ...
 ) {
-    let mut msg;
+    let msg;
     if msg_format.is_null() {
         return;
     }
@@ -1171,7 +1170,7 @@ pub unsafe fn dc_sqlite3_get_config(
     key: *const libc::c_char,
     def: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut stmt;
+    let stmt;
     if 0 == dc_sqlite3_is_open(sql) || key.is_null() {
         return dc_strdup_keep_null(def);
     }
@@ -1182,9 +1181,9 @@ pub unsafe fn dc_sqlite3_get_config(
     );
     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);
+        let 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);
+            let ret: *mut libc::c_char = dc_strdup(ptr as *const libc::c_char);
             sqlite3_finalize(stmt);
             return ret;
         }
@@ -1199,7 +1198,7 @@ pub unsafe fn dc_sqlite3_execute(
     querystr: *const libc::c_char,
 ) -> libc::c_int {
     let mut success = 0;
-    let mut sqlState;
+    let sqlState;
     let stmt = dc_sqlite3_prepare(context, sql, querystr);
     if !stmt.is_null() {
         sqlState = sqlite3_step(stmt);
@@ -1224,7 +1223,7 @@ pub unsafe fn dc_sqlite3_set_config_int(
     key: *const libc::c_char,
     value: int32_t,
 ) -> libc::c_int {
-    let mut value_str = dc_mprintf(
+    let value_str = dc_mprintf(
         b"%i\x00" as *const u8 as *const libc::c_char,
         value as libc::c_int,
     );
@@ -1243,11 +1242,11 @@ pub unsafe fn dc_sqlite3_get_config_int(
     key: *const libc::c_char,
     def: int32_t,
 ) -> int32_t {
-    let mut str = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
+    let str = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
     if str.is_null() {
         return def;
     }
-    let mut ret = atoi(str) as int32_t;
+    let ret = atoi(str) as int32_t;
     free(str as *mut libc::c_void);
     ret
 }
@@ -1259,7 +1258,7 @@ pub unsafe fn dc_sqlite3_table_exists(
 ) -> libc::c_int {
     let mut ret = 0;
     let mut stmt = 0 as *mut sqlite3_stmt;
-    let mut sqlState;
+    let sqlState;
 
     let querystr = sqlite3_mprintf(
         b"PRAGMA table_info(%s)\x00" as *const u8 as *const libc::c_char,
@@ -1297,7 +1296,7 @@ pub unsafe fn dc_sqlite3_set_config_int64(
     key: *const libc::c_char,
     value: int64_t,
 ) -> libc::c_int {
-    let mut value_str = dc_mprintf(
+    let value_str = dc_mprintf(
         b"%lld\x00" as *const u8 as *const libc::c_char,
         value as libc::c_long,
     );
@@ -1315,7 +1314,7 @@ pub unsafe fn dc_sqlite3_get_config_int64(
     key: *const libc::c_char,
     def: int64_t,
 ) -> int64_t {
-    let mut str = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
+    let str = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
     if str.is_null() {
         return def;
     }
@@ -1336,7 +1335,7 @@ pub unsafe fn dc_sqlite3_try_execute(
 ) -> libc::c_int {
     // same as dc_sqlite3_execute() but does not pass error to ui
     let mut success = 0;
-    let mut sql_state;
+    let sql_state;
     let stmt = dc_sqlite3_prepare(context, sql, querystr);
     if !stmt.is_null() {
         sql_state = sqlite3_step(stmt);
@@ -1367,13 +1366,13 @@ pub unsafe fn dc_sqlite3_get_rowid(
     // 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 = 0 as uint32_t;
-    let mut q3 = sqlite3_mprintf(
+    let 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 = dc_sqlite3_prepare(context, sql, q3);
+    let stmt = dc_sqlite3_prepare(context, sql, q3);
     if 100 == sqlite3_step(stmt) {
         id = sqlite3_column_int(stmt, 0) as uint32_t
     }
@@ -1394,7 +1393,7 @@ pub unsafe fn dc_sqlite3_get_rowid2(
     // same as dc_sqlite3_get_rowid() with a key over two columns
     let mut id = 0 as uint32_t;
     // see https://www.sqlite.org/printf.html for sqlite-printf modifiers
-    let mut q3 = sqlite3_mprintf(
+    let 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,
@@ -1403,7 +1402,7 @@ pub unsafe fn dc_sqlite3_get_rowid2(
         field2,
         value2,
     );
-    let mut stmt = dc_sqlite3_prepare(context, sql, q3);
+    let stmt = dc_sqlite3_prepare(context, sql, q3);
     if 100 == sqlite3_step(stmt) {
         id = sqlite3_column_int(stmt, 0) as uint32_t
     }
@@ -1413,8 +1412,8 @@ pub unsafe fn dc_sqlite3_get_rowid2(
 }
 
 pub unsafe fn dc_housekeeping(context: &dc_context_t) {
-    let mut stmt;
-    let mut dir_handle;
+    let stmt;
+    let dir_handle;
     let mut dir_entry;
     let mut files_in_use = dc_hash_t {
         keyClass: 0,
@@ -1494,8 +1493,8 @@ pub unsafe fn dc_housekeeping(context: &dc_context_t) {
                 break;
             }
             /* 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;
+            let name: *const libc::c_char = (*dir_entry).d_name.as_mut_ptr();
+            let name_len: libc::c_int = strlen(name) as libc::c_int;
             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
@@ -1578,10 +1577,10 @@ unsafe fn is_file_in_use(
     namespc: *const libc::c_char,
     name: *const libc::c_char,
 ) -> libc::c_int {
-    let mut name_to_check = dc_strdup(name);
+    let 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;
+        let name_len: libc::c_int = strlen(name) as libc::c_int;
+        let 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) != 0
         {
@@ -1589,7 +1588,7 @@ unsafe fn is_file_in_use(
         }
         *name_to_check.offset((name_len - namespc_len) as isize) = 0 as libc::c_char
     }
-    let mut ret: libc::c_int = (dc_hash_find(
+    let ret: libc::c_int = (dc_hash_find(
         files_in_use,
         name_to_check as *const libc::c_void,
         strlen(name_to_check) as libc::c_int,
@@ -1607,7 +1606,7 @@ unsafe fn maybe_add_file(files_in_use: *mut dc_hash_t, file: *const libc::c_char
     {
         return;
     }
-    let mut raw_name = &*file.offset(9isize) as *const libc::c_char;
+    let raw_name = &*file.offset(9isize) as *const libc::c_char;
     dc_hash_insert(
         files_in_use,
         raw_name as *const libc::c_void,
@@ -1622,11 +1621,11 @@ unsafe fn maybe_add_from_param(
     query: *const libc::c_char,
     param_id: libc::c_int,
 ) {
-    let mut param = dc_param_new();
-    let mut stmt = dc_sqlite3_prepare(context, &context.sql.clone().read().unwrap(), query);
+    let param = dc_param_new();
+    let stmt = dc_sqlite3_prepare(context, &context.sql.clone().read().unwrap(), 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);
+        let 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);
diff --git a/src/dc_stock.rs b/src/dc_stock.rs
index 195dced53..efd9c39d5 100644
--- a/src/dc_stock.rs
+++ b/src/dc_stock.rs
@@ -7,14 +7,14 @@ use crate::x::*;
 
 /* Return the string with the given ID by calling DC_EVENT_GET_STRING.
 The result must be free()'d! */
-pub unsafe fn dc_stock_str(mut context: &dc_context_t, mut id: libc::c_int) -> *mut libc::c_char {
+pub unsafe fn dc_stock_str(context: &dc_context_t, id: libc::c_int) -> *mut libc::c_char {
     return get_string(context, id, 0i32);
 }
 
 unsafe fn get_string(
-    mut context: &dc_context_t,
-    mut id: libc::c_int,
-    mut qty: libc::c_int,
+    context: &dc_context_t,
+    id: libc::c_int,
+    qty: libc::c_int,
 ) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char;
 
@@ -35,7 +35,7 @@ unsafe fn get_string(
 /* Add translated strings that are used by the messager backend.
 As the logging functions may use these strings, do not log any
 errors from here. */
-unsafe fn default_string(mut id: libc::c_int) -> *mut libc::c_char {
+unsafe fn default_string(id: libc::c_int) -> *mut libc::c_char {
     // TODO match on enum values /rtn
     match id {
         1 => {
@@ -216,9 +216,9 @@ unsafe fn default_string(mut id: libc::c_int) -> *mut libc::c_char {
 /* Replaces the first `%1$s` in the given String-ID by the given value.
 The result must be free()'d! */
 pub unsafe fn dc_stock_str_repl_string(
-    mut context: &dc_context_t,
-    mut id: libc::c_int,
-    mut to_insert: *const libc::c_char,
+    context: &dc_context_t,
+    id: libc::c_int,
+    to_insert: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = get_string(context, id, 0i32);
     dc_str_replace(
@@ -236,12 +236,12 @@ pub unsafe fn dc_stock_str_repl_string(
 }
 
 pub unsafe fn dc_stock_str_repl_int(
-    mut context: &dc_context_t,
-    mut id: libc::c_int,
-    mut to_insert_int: libc::c_int,
+    context: &dc_context_t,
+    id: libc::c_int,
+    to_insert_int: libc::c_int,
 ) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = get_string(context, id, to_insert_int);
-    let mut to_insert_str: *mut libc::c_char = dc_mprintf(
+    let to_insert_str: *mut libc::c_char = dc_mprintf(
         b"%i\x00" as *const u8 as *const libc::c_char,
         to_insert_int as libc::c_int,
     );
@@ -263,10 +263,10 @@ pub unsafe fn dc_stock_str_repl_int(
 /* Replaces the first `%1$s` and `%2$s` in the given String-ID by the two given strings.
 The result must be free()'d! */
 pub unsafe fn dc_stock_str_repl_string2(
-    mut context: &dc_context_t,
-    mut id: libc::c_int,
-    mut to_insert: *const libc::c_char,
-    mut to_insert2: *const libc::c_char,
+    context: &dc_context_t,
+    id: libc::c_int,
+    to_insert: *const libc::c_char,
+    to_insert2: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = get_string(context, id, 0i32);
     dc_str_replace(
@@ -295,26 +295,26 @@ pub unsafe fn dc_stock_str_repl_string2(
 
 /* Misc. */
 pub unsafe fn dc_stock_system_msg(
-    mut context: &dc_context_t,
-    mut str_id: libc::c_int,
+    context: &dc_context_t,
+    str_id: libc::c_int,
     mut param1: *const libc::c_char,
-    mut param2: *const libc::c_char,
-    mut from_id: uint32_t,
+    param2: *const libc::c_char,
+    from_id: uint32_t,
 ) -> *mut libc::c_char {
-    let mut ret: *mut libc::c_char;
+    let ret: *mut libc::c_char;
     let mut mod_contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
     let mut mod_displayname: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut from_contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
     let mut from_displayname: *mut libc::c_char = 0 as *mut libc::c_char;
     if str_id == 17i32 || str_id == 18i32 {
-        let mut mod_contact_id: uint32_t = dc_lookup_contact_id_by_addr(context, param1);
+        let mod_contact_id: uint32_t = dc_lookup_contact_id_by_addr(context, param1);
         if mod_contact_id != 0i32 as libc::c_uint {
             mod_contact = dc_get_contact(context, mod_contact_id);
             mod_displayname = dc_contact_get_name_n_addr(mod_contact);
             param1 = mod_displayname
         }
     }
-    let mut action: *mut libc::c_char = dc_stock_str_repl_string2(context, str_id, param1, param2);
+    let action: *mut libc::c_char = dc_stock_str_repl_string2(context, str_id, param1, param2);
     if 0 != from_id {
         if 0 != strlen(action)
             && *action.offset(strlen(action).wrapping_sub(1) as isize) as libc::c_int == '.' as i32
diff --git a/src/dc_strbuilder.rs b/src/dc_strbuilder.rs
index 5f6974a98..557b91ef2 100644
--- a/src/dc_strbuilder.rs
+++ b/src/dc_strbuilder.rs
@@ -9,10 +9,7 @@ pub struct dc_strbuilder_t {
     pub eos: *mut libc::c_char,
 }
 
-pub unsafe fn dc_strbuilder_init(
-    mut strbuilder: *mut dc_strbuilder_t,
-    mut init_bytes: libc::c_int,
-) {
+pub unsafe fn dc_strbuilder_init(mut strbuilder: *mut dc_strbuilder_t, init_bytes: libc::c_int) {
     if strbuilder.is_null() {
         return;
     }
@@ -31,19 +28,19 @@ pub unsafe fn dc_strbuilder_init(
 }
 pub unsafe fn dc_strbuilder_cat(
     mut strbuilder: *mut dc_strbuilder_t,
-    mut text: *const libc::c_char,
+    text: *const libc::c_char,
 ) -> *mut libc::c_char {
     if strbuilder.is_null() || text.is_null() {
         return 0 as *mut libc::c_char;
     }
-    let mut len: libc::c_int = strlen(text) as libc::c_int;
+    let len: libc::c_int = strlen(text) as libc::c_int;
     if len > (*strbuilder).free {
-        let mut add_bytes: libc::c_int = if len > (*strbuilder).allocated {
+        let add_bytes: libc::c_int = if len > (*strbuilder).allocated {
             len
         } else {
             (*strbuilder).allocated
         };
-        let mut old_offset: libc::c_int = (*strbuilder).eos.wrapping_offset_from((*strbuilder).buf)
+        let old_offset: libc::c_int = (*strbuilder).eos.wrapping_offset_from((*strbuilder).buf)
             as libc::c_long as libc::c_int;
         (*strbuilder).allocated = (*strbuilder).allocated + add_bytes;
         (*strbuilder).buf = realloc(
@@ -56,7 +53,7 @@ pub unsafe fn dc_strbuilder_cat(
         (*strbuilder).free = (*strbuilder).free + add_bytes;
         (*strbuilder).eos = (*strbuilder).buf.offset(old_offset as isize)
     }
-    let mut ret: *mut libc::c_char = (*strbuilder).eos;
+    let ret: *mut libc::c_char = (*strbuilder).eos;
     strcpy((*strbuilder).eos, text);
     (*strbuilder).eos = (*strbuilder).eos.offset(len as isize);
     (*strbuilder).free -= len;
diff --git a/src/dc_strencode.rs b/src/dc_strencode.rs
index 18280e53e..efd93129a 100644
--- a/src/dc_strencode.rs
+++ b/src/dc_strencode.rs
@@ -24,12 +24,12 @@ pub fn isdigit(mut _c: libc::c_int) -> libc::c_int {
     }
 }
 
-pub unsafe extern "C" fn dc_urlencode(mut to_encode: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe extern "C" fn dc_urlencode(to_encode: *const libc::c_char) -> *mut libc::c_char {
     let mut pstr: *const libc::c_char = to_encode;
     if to_encode.is_null() {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
     }
-    let mut buf: *mut libc::c_char =
+    let buf: *mut libc::c_char =
         malloc(strlen(to_encode).wrapping_mul(3).wrapping_add(1)) as *mut libc::c_char;
     let mut pbuf: *mut libc::c_char = buf;
     if buf.is_null() {
@@ -70,7 +70,7 @@ pub unsafe extern "C" fn dc_urlencode(mut to_encode: *const libc::c_char) -> *mu
 /* ******************************************************************************
  * URL encoding and decoding, RFC 3986
  ******************************************************************************/
-unsafe fn int_2_uppercase_hex(mut code: libc::c_char) -> libc::c_char {
+unsafe fn int_2_uppercase_hex(code: libc::c_char) -> libc::c_char {
     static mut hex: [libc::c_char; 17] = [
         48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 0,
     ];
@@ -78,12 +78,12 @@ unsafe fn int_2_uppercase_hex(mut code: libc::c_char) -> libc::c_char {
     hex[(code as libc::c_int & 15i32) as usize]
 }
 
-pub unsafe fn dc_urldecode(mut to_decode: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_urldecode(to_decode: *const libc::c_char) -> *mut libc::c_char {
     let mut pstr: *const libc::c_char = to_decode;
     if to_decode.is_null() {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
     }
-    let mut buf: *mut libc::c_char = malloc(strlen(to_decode).wrapping_add(1)) as *mut libc::c_char;
+    let buf: *mut libc::c_char = malloc(strlen(to_decode).wrapping_add(1)) as *mut libc::c_char;
     let mut pbuf: *mut libc::c_char = buf;
     if buf.is_null() {
         exit(50i32);
@@ -115,7 +115,7 @@ pub unsafe fn dc_urldecode(mut to_decode: *const libc::c_char) -> *mut libc::c_c
     buf
 }
 
-unsafe fn hex_2_int(mut ch: libc::c_char) -> libc::c_char {
+unsafe fn hex_2_int(ch: libc::c_char) -> libc::c_char {
     return (if 0 != isdigit(ch as libc::c_int) {
         ch as libc::c_int - '0' as i32
     } else {
@@ -123,11 +123,11 @@ unsafe fn hex_2_int(mut ch: libc::c_char) -> libc::c_char {
     }) as libc::c_char;
 }
 
-pub unsafe fn dc_encode_header_words(mut to_encode: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut libc::c_char {
     let mut current_block: u64;
     let mut ret_str: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut cur: *const libc::c_char = to_encode;
-    let mut mmapstr: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
+    let mmapstr: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
     if to_encode.is_null() || mmapstr.is_null() {
         current_block = 8550051112593613029;
     } else {
@@ -143,7 +143,7 @@ pub unsafe fn dc_encode_header_words(mut to_encode: *const libc::c_char) -> *mut
             }
             _ => {
                 if *cur as libc::c_int != '\u{0}' as i32 {
-                    let mut begin: *const libc::c_char;
+                    let begin: *const libc::c_char;
                     let mut end: *const libc::c_char;
                     let mut do_quote: libc::c_int;
                     let mut quote_words: libc::c_int;
@@ -224,10 +224,10 @@ pub unsafe fn dc_encode_header_words(mut to_encode: *const libc::c_char) -> *mut
 
 // TODO return bool /rtn
 unsafe fn quote_word(
-    mut display_charset: *const libc::c_char,
-    mut mmapstr: *mut MMAPString,
-    mut word: *const libc::c_char,
-    mut size: size_t,
+    display_charset: *const libc::c_char,
+    mmapstr: *mut MMAPString,
+    word: *const libc::c_char,
+    size: size_t,
 ) -> libc::c_int {
     let mut cur: *const libc::c_char;
     let mut i: size_t = 0i32 as size_t;
@@ -287,9 +287,9 @@ unsafe fn quote_word(
 }
 
 unsafe fn get_word(
-    mut begin: *const libc::c_char,
-    mut pend: *mut *const libc::c_char,
-    mut pto_be_quoted: *mut libc::c_int, // TODO should be bool /rtn
+    begin: *const libc::c_char,
+    pend: *mut *const libc::c_char,
+    pto_be_quoted: *mut libc::c_int, // TODO should be bool /rtn
 ) {
     let mut cur: *const libc::c_char = begin;
     while *cur as libc::c_int != ' ' as i32
@@ -311,7 +311,7 @@ unsafe fn get_word(
 
 /* see comment below */
 // TODO should be bool /rtn
-unsafe fn to_be_quoted(mut word: *const libc::c_char, mut size: size_t) -> libc::c_int {
+unsafe fn to_be_quoted(word: *const libc::c_char, size: size_t) -> libc::c_int {
     let mut cur: *const libc::c_char = word;
     let mut i: size_t = 0i32 as size_t;
     while i < size {
@@ -331,13 +331,13 @@ unsafe fn to_be_quoted(mut word: *const libc::c_char, mut size: size_t) -> libc:
     0
 }
 
-pub unsafe fn dc_decode_header_words(mut in_0: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_decode_header_words(in_0: *const libc::c_char) -> *mut libc::c_char {
     if in_0.is_null() {
         return 0 as *mut libc::c_char;
     }
     let mut out: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut cur_token: size_t = 0i32 as size_t;
-    let mut r: libc::c_int = mailmime_encoded_phrase_parse(
+    let r: libc::c_int = mailmime_encoded_phrase_parse(
         b"iso-8859-1\x00" as *const u8 as *const libc::c_char,
         in_0,
         strlen(in_0),
@@ -354,7 +354,7 @@ pub unsafe fn dc_decode_header_words(mut in_0: *const libc::c_char) -> *mut libc
 
 pub unsafe fn dc_encode_modified_utf7(
     mut to_encode: *const libc::c_char,
-    mut change_spaces: libc::c_int,
+    change_spaces: libc::c_int,
 ) -> *mut libc::c_char {
     let mut utf8pos: libc::c_uint;
     let mut utf8total: libc::c_uint;
@@ -365,7 +365,7 @@ pub unsafe fn dc_encode_modified_utf7(
     let mut ucs4: libc::c_ulong = 0;
     let mut bitbuf: libc::c_ulong = 0;
     let mut dst: *mut libc::c_char;
-    let mut res: *mut libc::c_char;
+    let res: *mut libc::c_char;
     if to_encode.is_null() {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
     }
@@ -504,8 +504,8 @@ static mut base64chars: [libc::c_char; 65] = [
 ];
 
 pub unsafe fn dc_decode_modified_utf7(
-    mut to_decode: *const libc::c_char,
-    mut change_spaces: libc::c_int,
+    to_decode: *const libc::c_char,
+    change_spaces: libc::c_int,
 ) -> *mut libc::c_char {
     let mut c: libc::c_uint;
     let mut i: libc::c_uint;
@@ -516,7 +516,7 @@ pub unsafe fn dc_decode_modified_utf7(
     let mut base64: [libc::c_uchar; 256] = [0; 256];
     let mut src: *const libc::c_char;
     let mut dst: *mut libc::c_char;
-    let mut res: *mut libc::c_char;
+    let res: *mut libc::c_char;
     if to_decode.is_null() {
         return dc_strdup(b"\x00" as *const u8 as *const libc::c_char);
     }
@@ -635,12 +635,12 @@ pub unsafe fn dc_needs_ext_header(mut to_check: *const libc::c_char) -> libc::c_
     0
 }
 
-pub unsafe fn dc_encode_ext_header(mut to_encode: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_encode_ext_header(to_encode: *const libc::c_char) -> *mut libc::c_char {
     let mut pstr: *const libc::c_char = to_encode;
     if to_encode.is_null() {
         return dc_strdup(b"utf-8\'\'\x00" as *const u8 as *const libc::c_char);
     }
-    let mut buf: *mut libc::c_char = malloc(
+    let buf: *mut libc::c_char = malloc(
         strlen(b"utf-8\'\'\x00" as *const u8 as *const libc::c_char)
             .wrapping_add(strlen(to_encode).wrapping_mul(3))
             .wrapping_add(1),
@@ -679,7 +679,7 @@ pub unsafe fn dc_encode_ext_header(mut to_encode: *const libc::c_char) -> *mut l
     buf
 }
 
-pub unsafe fn dc_decode_ext_header(mut to_decode: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_decode_ext_header(to_decode: *const libc::c_char) -> *mut libc::c_char {
     let mut decoded: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut charset: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut p2: *const libc::c_char;
@@ -703,7 +703,7 @@ pub unsafe fn dc_decode_ext_header(mut to_decode: *const libc::c_char) -> *mut l
                     && strcmp(charset, b"UTF-8\x00" as *const u8 as *const libc::c_char) != 0i32
                 {
                     let mut converted: *mut libc::c_char = 0 as *mut libc::c_char;
-                    let mut r: libc::c_int = charconv(
+                    let r: libc::c_int = charconv(
                         b"utf-8\x00" as *const u8 as *const libc::c_char,
                         charset,
                         decoded,
diff --git a/src/dc_token.rs b/src/dc_token.rs
index 6818a6d79..6483d38a7 100644
--- a/src/dc_token.rs
+++ b/src/dc_token.rs
@@ -10,10 +10,10 @@ pub const DC_TOKEN_AUTH: dc_tokennamespc_t = 110;
 pub const DC_TOKEN_INVITENUMBER: dc_tokennamespc_t = 100;
 // Functions to read/write token from/to the database. A token is any string associated with a key.
 pub unsafe fn dc_token_save(
-    mut context: &dc_context_t,
-    mut namespc: dc_tokennamespc_t,
-    mut foreign_id: uint32_t,
-    mut token: *const libc::c_char,
+    context: &dc_context_t,
+    namespc: dc_tokennamespc_t,
+    foreign_id: uint32_t,
+    token: *const libc::c_char,
 ) {
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
     if !token.is_null() {
@@ -33,12 +33,12 @@ pub unsafe fn dc_token_save(
     sqlite3_finalize(stmt);
 }
 pub unsafe fn dc_token_lookup(
-    mut context: &dc_context_t,
-    mut namespc: dc_tokennamespc_t,
-    mut foreign_id: uint32_t,
+    context: &dc_context_t,
+    namespc: dc_tokennamespc_t,
+    foreign_id: uint32_t,
 ) -> *mut libc::c_char {
-    let mut token: *mut libc::c_char;
-    let mut stmt: *mut sqlite3_stmt;
+    let token: *mut libc::c_char;
+    let stmt: *mut sqlite3_stmt;
     stmt = dc_sqlite3_prepare(
         context,
         &context.sql.clone().read().unwrap(),
@@ -55,9 +55,9 @@ pub unsafe fn dc_token_lookup(
 }
 
 pub unsafe fn dc_token_exists(
-    mut context: &dc_context_t,
-    mut namespc: dc_tokennamespc_t,
-    mut token: *const libc::c_char,
+    context: &dc_context_t,
+    namespc: dc_tokennamespc_t,
+    token: *const libc::c_char,
 ) -> libc::c_int {
     let mut exists: libc::c_int = 0i32;
     let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
diff --git a/src/dc_tools.rs b/src/dc_tools.rs
index 39ff4f342..a2e427161 100644
--- a/src/dc_tools.rs
+++ b/src/dc_tools.rs
@@ -15,14 +15,14 @@ no references to dc_context_t and other "larger" classes here. */
 // for carray etc.
 /* ** library-private **********************************************************/
 /* math tools */
-pub unsafe fn dc_exactly_one_bit_set(mut v: libc::c_int) -> libc::c_int {
+pub unsafe fn dc_exactly_one_bit_set(v: libc::c_int) -> libc::c_int {
     return (0 != v && 0 == v & v - 1i32) as libc::c_int;
 }
 
 /* string tools */
 /* dc_strdup() returns empty string if NULL is given, never returns NULL (exits on errors) */
-pub unsafe fn dc_strdup(mut s: *const libc::c_char) -> *mut libc::c_char {
-    let mut ret: *mut libc::c_char;
+pub unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
+    let ret: *mut libc::c_char;
     if !s.is_null() {
         ret = strdup(s);
         if ret.is_null() {
@@ -39,7 +39,7 @@ pub unsafe fn dc_strdup(mut s: *const libc::c_char) -> *mut libc::c_char {
 }
 
 /* strdup(NULL) is undefined, safe_strdup_keep_null(NULL) returns NULL in this case */
-pub unsafe fn dc_strdup_keep_null(mut s: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_strdup_keep_null(s: *const libc::c_char) -> *mut libc::c_char {
     return if !s.is_null() {
         dc_strdup(s)
     } else {
@@ -47,14 +47,13 @@ pub unsafe fn dc_strdup_keep_null(mut s: *const libc::c_char) -> *mut libc::c_ch
     };
 }
 
-pub unsafe fn dc_atoi_null_is_0(mut s: *const libc::c_char) -> libc::c_int {
+pub unsafe fn dc_atoi_null_is_0(s: *const libc::c_char) -> libc::c_int {
     return if !s.is_null() { atoi(s) } else { 0i32 };
 }
 
-pub unsafe fn dc_atof(mut str: *const libc::c_char) -> libc::c_double {
+pub unsafe fn dc_atof(str: *const libc::c_char) -> libc::c_double {
     // hack around atof() that may accept only `,` as decimal point on mac
-    let mut test: *mut libc::c_char =
-        dc_mprintf(b"%f\x00" as *const u8 as *const libc::c_char, 1.2f64);
+    let test: *mut libc::c_char = dc_mprintf(b"%f\x00" as *const u8 as *const libc::c_char, 1.2f64);
     *test.offset(2isize) = 0i32 as libc::c_char;
     let mut str_locale: *mut libc::c_char = dc_strdup(str);
     dc_str_replace(
@@ -62,7 +61,7 @@ pub unsafe fn dc_atof(mut str: *const libc::c_char) -> libc::c_double {
         b".\x00" as *const u8 as *const libc::c_char,
         test.offset(1isize),
     );
-    let mut f: libc::c_double = atof(str_locale);
+    let f: libc::c_double = atof(str_locale);
     free(test as *mut libc::c_void);
     free(str_locale as *mut libc::c_void);
 
@@ -70,14 +69,14 @@ pub unsafe fn dc_atof(mut str: *const libc::c_char) -> libc::c_double {
 }
 
 pub unsafe fn dc_str_replace(
-    mut haystack: *mut *mut libc::c_char,
-    mut needle: *const libc::c_char,
-    mut replacement: *const libc::c_char,
+    haystack: *mut *mut libc::c_char,
+    needle: *const libc::c_char,
+    replacement: *const libc::c_char,
 ) -> libc::c_int {
     let mut replacements: libc::c_int = 0i32;
     let mut start_search_pos: libc::c_int = 0i32;
-    let mut needle_len: libc::c_int;
-    let mut replacement_len: libc::c_int;
+    let needle_len: libc::c_int;
+    let replacement_len: libc::c_int;
     if haystack.is_null()
         || (*haystack).is_null()
         || needle.is_null()
@@ -101,7 +100,7 @@ pub unsafe fn dc_str_replace(
             + replacement_len as libc::c_long) as libc::c_int;
         *p2 = 0i32 as libc::c_char;
         p2 = p2.offset(needle_len as isize);
-        let mut new_string: *mut libc::c_char = dc_mprintf(
+        let new_string: *mut libc::c_char = dc_mprintf(
             b"%s%s%s\x00" as *const u8 as *const libc::c_char,
             *haystack,
             if !replacement.is_null() {
@@ -119,10 +118,9 @@ pub unsafe fn dc_str_replace(
     replacements
 }
 
-pub unsafe fn dc_ftoa(mut f: libc::c_double) -> *mut libc::c_char {
+pub unsafe fn dc_ftoa(f: libc::c_double) -> *mut libc::c_char {
     // hack around printf(%f) that may return `,` as decimal point on mac
-    let mut test: *mut libc::c_char =
-        dc_mprintf(b"%f\x00" as *const u8 as *const libc::c_char, 1.2f64);
+    let test: *mut libc::c_char = dc_mprintf(b"%f\x00" as *const u8 as *const libc::c_char, 1.2f64);
     *test.offset(2isize) = 0i32 as libc::c_char;
     let mut str: *mut libc::c_char = dc_mprintf(b"%f\x00" as *const u8 as *const libc::c_char, f);
     dc_str_replace(
@@ -135,7 +133,7 @@ pub unsafe fn dc_ftoa(mut f: libc::c_double) -> *mut libc::c_char {
     str
 }
 
-pub unsafe fn dc_ltrim(mut buf: *mut libc::c_char) {
+pub unsafe fn dc_ltrim(buf: *mut libc::c_char) {
     let mut len: size_t;
     let mut cur: *const libc::c_uchar;
     if !buf.is_null() && 0 != *buf as libc::c_int {
@@ -155,7 +153,7 @@ pub unsafe fn dc_ltrim(mut buf: *mut libc::c_char) {
     };
 }
 
-pub unsafe fn dc_rtrim(mut buf: *mut libc::c_char) {
+pub unsafe fn dc_rtrim(buf: *mut libc::c_char) {
     let mut len: size_t;
     let mut cur: *mut libc::c_uchar;
     if !buf.is_null() && 0 != *buf as libc::c_int {
@@ -177,14 +175,14 @@ pub unsafe fn dc_rtrim(mut buf: *mut libc::c_char) {
     };
 }
 
-pub unsafe fn dc_trim(mut buf: *mut libc::c_char) {
+pub unsafe fn dc_trim(buf: *mut libc::c_char) {
     dc_ltrim(buf);
     dc_rtrim(buf);
 }
 
 /* the result must be free()'d */
-pub unsafe fn dc_strlower(mut in_0: *const libc::c_char) -> *mut libc::c_char {
-    let mut out: *mut libc::c_char = dc_strdup(in_0);
+pub unsafe fn dc_strlower(in_0: *const libc::c_char) -> *mut libc::c_char {
+    let out: *mut libc::c_char = dc_strdup(in_0);
     let mut p: *mut libc::c_char = out;
     while 0 != *p {
         *p = libc::tolower(*p as libc::c_int) as libc::c_char;
@@ -194,7 +192,7 @@ pub unsafe fn dc_strlower(mut in_0: *const libc::c_char) -> *mut libc::c_char {
     out
 }
 
-pub unsafe fn dc_strlower_in_place(mut in_0: *mut libc::c_char) {
+pub unsafe fn dc_strlower_in_place(in_0: *mut libc::c_char) {
     let mut p: *mut libc::c_char = in_0;
     while 0 != *p {
         *p = libc::tolower(*p as libc::c_int) as libc::c_char;
@@ -203,8 +201,8 @@ pub unsafe fn dc_strlower_in_place(mut in_0: *mut libc::c_char) {
 }
 
 pub unsafe fn dc_str_contains(
-    mut haystack: *const libc::c_char,
-    mut needle: *const libc::c_char,
+    haystack: *const libc::c_char,
+    needle: *const libc::c_char,
 ) -> libc::c_int {
     if haystack.is_null() || needle.is_null() {
         return 0i32;
@@ -212,9 +210,9 @@ pub unsafe fn dc_str_contains(
     if !strstr(haystack, needle).is_null() {
         return 1i32;
     }
-    let mut haystack_lower: *mut libc::c_char = dc_strlower(haystack);
-    let mut needle_lower: *mut libc::c_char = dc_strlower(needle);
-    let mut ret: libc::c_int = if !strstr(haystack_lower, needle_lower).is_null() {
+    let haystack_lower: *mut libc::c_char = dc_strlower(haystack);
+    let needle_lower: *mut libc::c_char = dc_strlower(needle);
+    let ret: libc::c_int = if !strstr(haystack_lower, needle_lower).is_null() {
         1i32
     } else {
         0i32
@@ -227,10 +225,10 @@ pub unsafe fn dc_str_contains(
 
 /* the result must be free()'d */
 pub unsafe fn dc_null_terminate(
-    mut in_0: *const libc::c_char,
-    mut bytes: libc::c_int,
+    in_0: *const libc::c_char,
+    bytes: libc::c_int,
 ) -> *mut libc::c_char {
-    let mut out: *mut libc::c_char = malloc(bytes as usize + 1) as *mut libc::c_char;
+    let out: *mut libc::c_char = malloc(bytes as usize + 1) as *mut libc::c_char;
     if out.is_null() {
         exit(45i32);
     }
@@ -242,7 +240,7 @@ pub unsafe fn dc_null_terminate(
     out
 }
 
-pub unsafe fn dc_binary_to_uc_hex(mut buf: *const uint8_t, mut bytes: size_t) -> *mut libc::c_char {
+pub unsafe fn dc_binary_to_uc_hex(buf: *const uint8_t, bytes: size_t) -> *mut libc::c_char {
     let mut hex: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut i;
     if !(buf.is_null() || bytes <= 0) {
@@ -268,7 +266,7 @@ pub unsafe fn dc_binary_to_uc_hex(mut buf: *const uint8_t, mut bytes: size_t) ->
 }
 
 /* remove all \r characters from string */
-pub unsafe extern "C" fn dc_remove_cr_chars(mut buf: *mut libc::c_char) {
+pub unsafe extern "C" fn dc_remove_cr_chars(buf: *mut libc::c_char) {
     /* search for first `\r` */
     let mut p1: *const libc::c_char = buf;
     while 0 != *p1 {
@@ -289,22 +287,22 @@ pub unsafe extern "C" fn dc_remove_cr_chars(mut buf: *mut libc::c_char) {
     *p2 = 0i32 as libc::c_char;
 }
 
-pub unsafe fn dc_unify_lineends(mut buf: *mut libc::c_char) {
+pub unsafe fn dc_unify_lineends(buf: *mut libc::c_char) {
     dc_remove_cr_chars(buf);
 }
 
 /* replace bad UTF-8 characters by sequences of `_` (to avoid problems in filenames, we do not use eg. `?`) the function is useful if strings are unexpectingly encoded eg. as ISO-8859-1 */
-pub unsafe fn dc_replace_bad_utf8_chars(mut buf: *mut libc::c_char) {
-    let mut current_block: u64;
+pub unsafe fn dc_replace_bad_utf8_chars(buf: *mut libc::c_char) {
+    let current_block: u64;
     if buf.is_null() {
         return;
     }
     /* force unsigned - otherwise the `> ' '` comparison will fail */
     let mut p1: *mut libc::c_uchar = buf as *mut libc::c_uchar;
-    let mut p1len: libc::c_int = strlen(buf) as libc::c_int;
+    let p1len: libc::c_int = strlen(buf) as libc::c_int;
     let mut c: libc::c_int;
     let mut i: libc::c_int;
-    let mut ix: libc::c_int;
+    let ix: libc::c_int;
     let mut n: libc::c_int;
     let mut j: libc::c_int;
     i = 0i32;
@@ -362,7 +360,7 @@ pub unsafe fn dc_replace_bad_utf8_chars(mut buf: *mut libc::c_char) {
     };
 }
 
-pub unsafe fn dc_utf8_strlen(mut s: *const libc::c_char) -> size_t {
+pub unsafe fn dc_utf8_strlen(s: *const libc::c_char) -> size_t {
     if s.is_null() {
         return 0i32 as size_t;
     }
@@ -378,7 +376,7 @@ pub unsafe fn dc_utf8_strlen(mut s: *const libc::c_char) -> size_t {
     j
 }
 
-pub unsafe fn dc_truncate_str(mut buf: *mut libc::c_char, mut approx_chars: libc::c_int) {
+pub unsafe fn dc_truncate_str(buf: *mut libc::c_char, approx_chars: libc::c_int) {
     if approx_chars > 0
         && strlen(buf)
             > approx_chars.wrapping_add(
@@ -400,15 +398,15 @@ pub unsafe fn dc_truncate_str(mut buf: *mut libc::c_char, mut approx_chars: libc
 }
 
 pub unsafe fn dc_truncate_n_unwrap_str(
-    mut buf: *mut libc::c_char,
-    mut approx_characters: libc::c_int,
-    mut do_unwrap: libc::c_int,
+    buf: *mut libc::c_char,
+    approx_characters: libc::c_int,
+    do_unwrap: libc::c_int,
 ) {
     /* Function unwraps the given string and removes unnecessary whitespace.
     Function stops processing after approx_characters are processed.
     (as we're using UTF-8, for simplicity, we cut the string only at whitespaces). */
     /* a single line is truncated `...` instead of `[...]` (the former is typically also used by the UI to fit strings in a rectangle) */
-    let mut ellipse_utf8: *const libc::c_char = if 0 != do_unwrap {
+    let ellipse_utf8: *const libc::c_char = if 0 != do_unwrap {
         b" ...\x00" as *const u8 as *const libc::c_char
     } else {
         b" [...]\x00" as *const u8 as *const libc::c_char
@@ -420,9 +418,9 @@ pub unsafe fn dc_truncate_n_unwrap_str(
         if *p1 as libc::c_int > ' ' as i32 {
             lastIsCharacter = 1i32
         } else if 0 != lastIsCharacter {
-            let mut used_bytes: size_t = (p1 as uintptr_t).wrapping_sub(buf as uintptr_t) as size_t;
+            let used_bytes: size_t = (p1 as uintptr_t).wrapping_sub(buf as uintptr_t) as size_t;
             if dc_utf8_strnlen(buf, used_bytes) >= approx_characters as usize {
-                let mut buf_bytes: size_t = strlen(buf);
+                let buf_bytes: size_t = strlen(buf);
                 if buf_bytes.wrapping_sub(used_bytes) >= strlen(ellipse_utf8) {
                     strcpy(p1 as *mut libc::c_char, ellipse_utf8);
                 }
@@ -443,7 +441,7 @@ pub unsafe fn dc_truncate_n_unwrap_str(
     };
 }
 
-unsafe fn dc_utf8_strnlen(mut s: *const libc::c_char, mut n: size_t) -> size_t {
+unsafe fn dc_utf8_strnlen(s: *const libc::c_char, n: size_t) -> size_t {
     if s.is_null() {
         return 0i32 as size_t;
     }
@@ -460,8 +458,8 @@ unsafe fn dc_utf8_strnlen(mut s: *const libc::c_char, mut n: size_t) -> size_t {
 }
 
 /* split string into lines*/
-pub unsafe fn dc_split_into_lines(mut buf_terminated: *const libc::c_char) -> *mut carray {
-    let mut lines: *mut carray = carray_new(1024i32 as libc::c_uint);
+pub unsafe fn dc_split_into_lines(buf_terminated: *const libc::c_char) -> *mut carray {
+    let lines: *mut carray = carray_new(1024i32 as libc::c_uint);
     let mut line_chars = 0;
     let mut p1: *const libc::c_char = buf_terminated;
     let mut line_start: *const libc::c_char = p1;
@@ -490,10 +488,10 @@ pub unsafe fn dc_split_into_lines(mut buf_terminated: *const libc::c_char) -> *m
     lines
 }
 
-pub unsafe fn dc_free_splitted_lines(mut lines: *mut carray) {
+pub unsafe fn dc_free_splitted_lines(lines: *mut carray) {
     if !lines.is_null() {
         let mut i: libc::c_int;
-        let mut cnt: libc::c_int = carray_count(lines) as libc::c_int;
+        let cnt: libc::c_int = carray_count(lines) as libc::c_int;
         i = 0i32;
         while i < cnt {
             free(carray_get(lines, i as libc::c_uint));
@@ -505,18 +503,18 @@ pub unsafe fn dc_free_splitted_lines(mut lines: *mut carray) {
 
 /* insert a break every n characters, the return must be free()'d */
 pub unsafe fn dc_insert_breaks(
-    mut in_0: *const libc::c_char,
-    mut break_every: libc::c_int,
-    mut break_chars: *const libc::c_char,
+    in_0: *const libc::c_char,
+    break_every: libc::c_int,
+    break_chars: *const libc::c_char,
 ) -> *mut libc::c_char {
     if in_0.is_null() || break_every <= 0i32 || break_chars.is_null() {
         return dc_strdup(in_0);
     }
     let mut out_len = strlen(in_0);
     let mut chars_added = 0;
-    let mut break_chars_len = strlen(break_chars);
+    let break_chars_len = strlen(break_chars);
     out_len += (out_len / break_every as usize + 1) * break_chars_len + 1;
-    let mut out: *mut libc::c_char = malloc(out_len) as *mut libc::c_char;
+    let out: *mut libc::c_char = malloc(out_len) as *mut libc::c_char;
     if out.is_null() {
         return 0 as *mut libc::c_char;
     }
@@ -541,8 +539,8 @@ pub unsafe fn dc_insert_breaks(
 }
 
 pub unsafe fn dc_str_from_clist(
-    mut list: *const clist,
-    mut delimiter: *const libc::c_char,
+    list: *const clist,
+    delimiter: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut str: dc_strbuilder_t = dc_strbuilder_t {
         buf: 0 as *mut libc::c_char,
@@ -554,7 +552,7 @@ pub unsafe fn dc_str_from_clist(
     if !list.is_null() {
         let mut cur: *mut clistiter = (*list).first;
         while !cur.is_null() {
-            let mut rfc724_mid: *const libc::c_char = (if !cur.is_null() {
+            let rfc724_mid: *const libc::c_char = (if !cur.is_null() {
                 (*cur).data
             } else {
                 0 as *mut libc::c_void
@@ -577,17 +575,17 @@ pub unsafe fn dc_str_from_clist(
 }
 
 pub unsafe fn dc_str_to_clist(
-    mut str: *const libc::c_char,
-    mut delimiter: *const libc::c_char,
+    str: *const libc::c_char,
+    delimiter: *const libc::c_char,
 ) -> *mut clist {
-    let mut list: *mut clist = clist_new();
+    let list: *mut clist = clist_new();
     if list.is_null() {
         exit(54i32);
     }
     if !str.is_null() && !delimiter.is_null() && strlen(delimiter) >= 1 {
         let mut p1: *const libc::c_char = str;
         loop {
-            let mut p2: *const libc::c_char = strstr(p1, delimiter);
+            let p2: *const libc::c_char = strstr(p1, delimiter);
             if p2.is_null() {
                 clist_insert_after(list, (*list).last, strdup(p1) as *mut libc::c_void);
                 break;
@@ -608,8 +606,8 @@ pub unsafe fn dc_str_to_clist(
     list
 }
 
-pub unsafe fn dc_str_to_color(mut str: *const libc::c_char) -> libc::c_int {
-    let mut str_lower: *mut libc::c_char = dc_strlower(str);
+pub unsafe fn dc_str_to_color(str: *const libc::c_char) -> libc::c_int {
+    let str_lower: *mut libc::c_char = dc_strlower(str);
     /* the colors must fulfill some criterions as:
     - contrast to black and to white
     - work as a text-color
@@ -635,14 +633,14 @@ pub unsafe fn dc_str_to_color(mut str: *const libc::c_char) -> libc::c_int {
         0xbe450ci32 as uint32_t,
     ];
     let mut checksum: libc::c_int = 0i32;
-    let mut str_len: libc::c_int = strlen(str_lower) as libc::c_int;
+    let str_len: libc::c_int = strlen(str_lower) as libc::c_int;
     let mut i: libc::c_int = 0i32;
     while i < str_len {
         checksum += (i + 1i32) * *str_lower.offset(i as isize) as libc::c_int;
         checksum %= 0xffffffi32;
         i += 1
     }
-    let mut color_index: libc::c_int = (checksum as libc::c_ulong).wrapping_rem(
+    let color_index: libc::c_int = (checksum as libc::c_ulong).wrapping_rem(
         (::std::mem::size_of::<[uint32_t; 16]>() as libc::c_ulong)
             .wrapping_div(::std::mem::size_of::<uint32_t>() as libc::c_ulong),
     ) as libc::c_int;
@@ -653,7 +651,7 @@ pub unsafe fn dc_str_to_color(mut str: *const libc::c_char) -> libc::c_int {
 
 /* clist tools */
 /* calls free() for each item content */
-pub unsafe fn clist_free_content(mut haystack: *const clist) {
+pub unsafe fn clist_free_content(haystack: *const clist) {
     let mut iter: *mut clistiter = (*haystack).first;
     while !iter.is_null() {
         free((*iter).data);
@@ -667,8 +665,8 @@ pub unsafe fn clist_free_content(mut haystack: *const clist) {
 }
 
 pub unsafe fn clist_search_string_nocase(
-    mut haystack: *const clist,
-    mut needle: *const libc::c_char,
+    haystack: *const clist,
+    needle: *const libc::c_char,
 ) -> libc::c_int {
     let mut iter: *mut clistiter = (*haystack).first;
     while !iter.is_null() {
@@ -687,7 +685,7 @@ pub unsafe fn clist_search_string_nocase(
 
 /* date/time tools */
 /* the result is UTC or DC_INVALID_TIMESTAMP */
-pub unsafe fn dc_timestamp_from_date(mut date_time: *mut mailimf_date_time) -> time_t {
+pub unsafe fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> time_t {
     let mut tmval: tm = tm {
         tm_sec: 0,
         tm_min: 0,
@@ -702,8 +700,8 @@ pub unsafe fn dc_timestamp_from_date(mut date_time: *mut mailimf_date_time) -> t
         tm_zone: 0 as *mut libc::c_char,
     };
     let mut timeval: time_t;
-    let mut zone_min: libc::c_int;
-    let mut zone_hour: libc::c_int;
+    let zone_min: libc::c_int;
+    let zone_hour: libc::c_int;
     memset(
         &mut tmval as *mut tm as *mut libc::c_void,
         0,
@@ -732,10 +730,10 @@ pub unsafe fn dc_timestamp_from_date(mut date_time: *mut mailimf_date_time) -> t
     timeval
 }
 
-pub unsafe fn mkgmtime(mut tmp: *mut tm) -> time_t {
+pub unsafe fn mkgmtime(tmp: *mut tm) -> time_t {
     let mut dir: libc::c_int;
     let mut bits: libc::c_int;
-    let mut saved_seconds: libc::c_int;
+    let saved_seconds: libc::c_int;
     let mut t: time_t;
     let mut yourtm: tm;
     let mut mytm: tm = tm {
@@ -795,7 +793,7 @@ pub unsafe fn mkgmtime(mut tmp: *mut tm) -> time_t {
 /* ******************************************************************************
  * date/time tools
  ******************************************************************************/
-unsafe fn tmcomp(mut atmp: *mut tm, mut btmp: *mut tm) -> libc::c_int {
+unsafe fn tmcomp(atmp: *mut tm, btmp: *mut tm) -> libc::c_int {
     let mut result: libc::c_int;
     result = (*atmp).tm_year - (*btmp).tm_year;
     if result == 0i32
@@ -876,10 +874,10 @@ pub unsafe fn dc_gm2local_offset() -> libc::c_long {
 }
 
 /* timesmearing */
-pub unsafe fn dc_smeared_time(mut context: &dc_context_t) -> time_t {
+pub unsafe fn dc_smeared_time(context: &dc_context_t) -> time_t {
     /* function returns a corrected time(NULL) */
     let mut now: time_t = time(0 as *mut time_t);
-    let mut ts = *context.last_smeared_timestamp.clone().read().unwrap();
+    let ts = *context.last_smeared_timestamp.clone().read().unwrap();
     if ts >= now {
         now = ts + 1;
     }
@@ -887,11 +885,11 @@ pub unsafe fn dc_smeared_time(mut context: &dc_context_t) -> time_t {
     now
 }
 
-pub unsafe fn dc_create_smeared_timestamp(mut context: &dc_context_t) -> time_t {
-    let mut now: time_t = time(0 as *mut time_t);
+pub unsafe fn dc_create_smeared_timestamp(context: &dc_context_t) -> time_t {
+    let now: time_t = time(0 as *mut time_t);
     let mut ret: time_t = now;
 
-    let mut ts = *context.last_smeared_timestamp.clone().write().unwrap();
+    let ts = *context.last_smeared_timestamp.clone().write().unwrap();
     if ret <= ts {
         ret = ts + 1;
         if ret - now > 5 {
@@ -902,16 +900,13 @@ pub unsafe fn dc_create_smeared_timestamp(mut context: &dc_context_t) -> time_t
     ret
 }
 
-pub unsafe fn dc_create_smeared_timestamps(
-    mut context: &dc_context_t,
-    mut count: libc::c_int,
-) -> time_t {
+pub unsafe fn dc_create_smeared_timestamps(context: &dc_context_t, count: libc::c_int) -> time_t {
     /* get a range to timestamps that can be used uniquely */
-    let mut now: time_t = time(0 as *mut time_t);
+    let now: time_t = time(0 as *mut time_t);
     let mut start: time_t =
         now + (if count < 5i32 { count } else { 5i32 }) as libc::c_long - count as libc::c_long;
 
-    let mut ts = *context.last_smeared_timestamp.clone().write().unwrap();
+    let ts = *context.last_smeared_timestamp.clone().write().unwrap();
     start = if ts + 1 > start { ts + 1 } else { start };
 
     start
@@ -931,7 +926,7 @@ pub unsafe fn dc_create_id() -> *mut libc::c_char {
     - the group-id should be a string with the characters [a-zA-Z0-9\-_] */
 
     let mut rng = thread_rng();
-    let mut buf: [uint32_t; 3] = [rng.gen(), rng.gen(), rng.gen()];
+    let buf: [uint32_t; 3] = [rng.gen(), rng.gen(), rng.gen()];
 
     encode_66bits_as_base64(buf[0usize], buf[1usize], buf[2usize])
 }
@@ -939,16 +934,12 @@ pub unsafe fn dc_create_id() -> *mut libc::c_char {
 /* ******************************************************************************
  * generate Message-IDs
  ******************************************************************************/
-unsafe fn encode_66bits_as_base64(
-    mut v1: uint32_t,
-    mut v2: uint32_t,
-    mut fill: uint32_t,
-) -> *mut libc::c_char {
+unsafe fn encode_66bits_as_base64(v1: uint32_t, v2: uint32_t, fill: uint32_t) -> *mut libc::c_char {
     /* encode 66 bits as a base64 string. This is useful for ID generating with short strings as
     we save 5 character in each id compared to 64 bit hex encoding, for a typical group ID, these are 10 characters (grpid+msgid):
     hex:    64 bit, 4 bits/character, length = 64/4 = 16 characters
     base64: 64 bit, 6 bits/character, length = 64/6 = 11 characters (plus 2 additional bits) */
-    let mut ret: *mut libc::c_char = malloc(12) as *mut libc::c_char;
+    let ret: *mut libc::c_char = malloc(12) as *mut libc::c_char;
     if ret.is_null() {
         exit(34i32);
     }
@@ -977,19 +968,19 @@ unsafe fn encode_66bits_as_base64(
 }
 
 pub unsafe fn dc_create_incoming_rfc724_mid(
-    mut message_timestamp: time_t,
-    mut contact_id_from: uint32_t,
-    mut contact_ids_to: *mut dc_array_t,
+    message_timestamp: time_t,
+    contact_id_from: uint32_t,
+    contact_ids_to: *mut dc_array_t,
 ) -> *mut libc::c_char {
     if contact_ids_to.is_null() || dc_array_get_cnt(contact_ids_to) == 0 {
         return 0 as *mut libc::c_char;
     }
     /* find out the largest receiver ID (we could also take the smallest, but it should be unique) */
     let mut i: size_t = 0i32 as size_t;
-    let mut icnt: size_t = dc_array_get_cnt(contact_ids_to);
+    let icnt: size_t = dc_array_get_cnt(contact_ids_to);
     let mut largest_id_to: uint32_t = 0i32 as uint32_t;
     while i < icnt {
-        let mut cur_id: uint32_t = dc_array_get_id(contact_ids_to, i);
+        let cur_id: uint32_t = dc_array_get_id(contact_ids_to, i);
         if cur_id > largest_id_to {
             largest_id_to = cur_id
         }
@@ -1005,16 +996,16 @@ pub unsafe fn dc_create_incoming_rfc724_mid(
 }
 
 pub unsafe fn dc_create_outgoing_rfc724_mid(
-    mut grpid: *const libc::c_char,
-    mut from_addr: *const libc::c_char,
+    grpid: *const libc::c_char,
+    from_addr: *const libc::c_char,
 ) -> *mut libc::c_char {
     /* Function generates a Message-ID that can be used for a new outgoing message.
     - this function is called for all outgoing messages.
     - the message ID should be globally unique
     - do not add a counter or any private data as as this may give unneeded information to the receiver	*/
     let mut rand1: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut rand2: *mut libc::c_char = dc_create_id();
-    let mut ret: *mut libc::c_char;
+    let rand2: *mut libc::c_char = dc_create_id();
+    let ret: *mut libc::c_char;
     let mut at_hostname: *const libc::c_char = strchr(from_addr, '@' as i32);
     if at_hostname.is_null() {
         at_hostname = b"@nohost\x00" as *const u8 as *const libc::c_char
@@ -1041,12 +1032,12 @@ pub unsafe fn dc_create_outgoing_rfc724_mid(
     ret
 }
 
-pub unsafe fn dc_extract_grpid_from_rfc724_mid(mut mid: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_extract_grpid_from_rfc724_mid(mid: *const libc::c_char) -> *mut libc::c_char {
     /* extract our group ID from Message-IDs as `Gr.12345678901.morerandom@domain.de`; "12345678901" is the wanted ID in this example. */
     let mut success: libc::c_int = 0i32;
     let mut grpid: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut p1: *mut libc::c_char;
-    let mut grpid_len: libc::c_int;
+    let p1: *mut libc::c_char;
+    let grpid_len: libc::c_int;
     if !(mid.is_null()
         || strlen(mid) < 8
         || *mid.offset(0isize) as libc::c_int != 'G' as i32
@@ -1075,16 +1066,16 @@ pub unsafe fn dc_extract_grpid_from_rfc724_mid(mut mid: *const libc::c_char) ->
     };
 }
 
-pub unsafe fn dc_extract_grpid_from_rfc724_mid_list(mut list: *const clist) -> *mut libc::c_char {
+pub unsafe fn dc_extract_grpid_from_rfc724_mid_list(list: *const clist) -> *mut libc::c_char {
     if !list.is_null() {
         let mut cur: *mut clistiter = (*list).first;
         while !cur.is_null() {
-            let mut mid: *const libc::c_char = (if !cur.is_null() {
+            let mid: *const libc::c_char = (if !cur.is_null() {
                 (*cur).data
             } else {
                 0 as *mut libc::c_void
             }) as *const libc::c_char;
-            let mut grpid: *mut libc::c_char = dc_extract_grpid_from_rfc724_mid(mid);
+            let grpid: *mut libc::c_char = dc_extract_grpid_from_rfc724_mid(mid);
             if !grpid.is_null() {
                 return grpid;
             }
@@ -1100,8 +1091,8 @@ pub unsafe fn dc_extract_grpid_from_rfc724_mid_list(mut list: *const clist) -> *
 }
 
 /* file tools */
-pub unsafe fn dc_ensure_no_slash(mut pathNfilename: *mut libc::c_char) {
-    let mut path_len: libc::c_int = strlen(pathNfilename) as libc::c_int;
+pub unsafe fn dc_ensure_no_slash(pathNfilename: *mut libc::c_char) {
+    let path_len: libc::c_int = strlen(pathNfilename) as libc::c_int;
     if path_len > 0i32 {
         if *pathNfilename.offset((path_len - 1i32) as isize) as libc::c_int == '/' as i32
             || *pathNfilename.offset((path_len - 1i32) as isize) as libc::c_int == '\\' as i32
@@ -1111,7 +1102,7 @@ pub unsafe fn dc_ensure_no_slash(mut pathNfilename: *mut libc::c_char) {
     };
 }
 
-pub unsafe fn dc_validate_filename(mut filename: *mut libc::c_char) {
+pub unsafe fn dc_validate_filename(filename: *mut libc::c_char) {
     /* function modifies the given buffer and replaces all characters not valid in filenames by a "-" */
     let mut p1: *mut libc::c_char = filename;
     while 0 != *p1 {
@@ -1125,7 +1116,7 @@ pub unsafe fn dc_validate_filename(mut filename: *mut libc::c_char) {
     }
 }
 
-pub unsafe fn dc_get_filename(mut pathNfilename: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_get_filename(pathNfilename: *const libc::c_char) -> *mut libc::c_char {
     let mut p: *const libc::c_char = strrchr(pathNfilename, '/' as i32);
     if p.is_null() {
         p = strrchr(pathNfilename, '\\' as i32)
@@ -1140,18 +1131,18 @@ pub unsafe fn dc_get_filename(mut pathNfilename: *const libc::c_char) -> *mut li
 
 // the case of the suffix is preserved
 pub unsafe fn dc_split_filename(
-    mut pathNfilename: *const libc::c_char,
-    mut ret_basename: *mut *mut libc::c_char,
-    mut ret_all_suffixes_incl_dot: *mut *mut libc::c_char,
+    pathNfilename: *const libc::c_char,
+    ret_basename: *mut *mut libc::c_char,
+    ret_all_suffixes_incl_dot: *mut *mut libc::c_char,
 ) {
     /* splits a filename into basename and all suffixes, eg. "/path/foo.tar.gz" is split into "foo.tar" and ".gz",
     (we use the _last_ dot which allows the usage inside the filename which are very usual;
     maybe the detection could be more intelligent, however, for the moment, it is just file)
     - if there is no suffix, the returned suffix string is empty, eg. "/path/foobar" is split into "foobar" and ""
     - the case of the returned suffix is preserved; this is to allow reconstruction of (similar) names */
-    let mut basename: *mut libc::c_char = dc_get_filename(pathNfilename);
-    let mut suffix: *mut libc::c_char;
-    let mut p1: *mut libc::c_char = strrchr(basename, '.' as i32);
+    let basename: *mut libc::c_char = dc_get_filename(pathNfilename);
+    let suffix: *mut libc::c_char;
+    let p1: *mut libc::c_char = strrchr(basename, '.' as i32);
     if !p1.is_null() {
         suffix = dc_strdup(p1);
         *p1 = 0i32 as libc::c_char
@@ -1171,7 +1162,7 @@ pub unsafe fn dc_split_filename(
 }
 
 // the returned suffix is lower-case
-pub unsafe fn dc_get_filesuffix_lc(mut pathNfilename: *const libc::c_char) -> *mut libc::c_char {
+pub unsafe fn dc_get_filesuffix_lc(pathNfilename: *const libc::c_char) -> *mut libc::c_char {
     if !pathNfilename.is_null() {
         let mut p: *const libc::c_char = strrchr(pathNfilename, '.' as i32);
         if !p.is_null() {
@@ -1184,10 +1175,10 @@ pub unsafe fn dc_get_filesuffix_lc(mut pathNfilename: *const libc::c_char) -> *m
 }
 
 pub unsafe fn dc_get_filemeta(
-    mut buf_start: *const libc::c_void,
-    mut buf_bytes: size_t,
-    mut ret_width: *mut uint32_t,
-    mut ret_height: *mut uint32_t,
+    buf_start: *const libc::c_void,
+    buf_bytes: size_t,
+    ret_width: *mut uint32_t,
+    ret_height: *mut uint32_t,
 ) -> libc::c_int {
     /* Strategy:
     reading GIF dimensions requires the first 10 bytes of the file
@@ -1195,7 +1186,7 @@ pub unsafe fn dc_get_filemeta(
     reading JPEG dimensions requires scanning through jpeg chunks
     In all formats, the file is at least 24 bytes big, so we'll read that always
     inspired by http://www.cplusplus.com/forum/beginner/45217/ */
-    let mut buf: *const libc::c_uchar = buf_start as *const libc::c_uchar;
+    let buf: *const libc::c_uchar = buf_start as *const libc::c_uchar;
     if buf_bytes < 24 {
         return 0i32;
     }
@@ -1268,10 +1259,10 @@ pub unsafe fn dc_get_filemeta(
 }
 
 pub unsafe fn dc_get_abs_path(
-    mut context: &dc_context_t,
-    mut pathNfilename: *const libc::c_char,
+    context: &dc_context_t,
+    pathNfilename: *const libc::c_char,
 ) -> *mut libc::c_char {
-    let mut current_block: u64;
+    let current_block: u64;
     let mut success: libc::c_int = 0i32;
     let mut pathNfilename_abs: *mut libc::c_char = 0 as *mut libc::c_char;
     if !pathNfilename.is_null() {
@@ -1309,8 +1300,8 @@ pub unsafe fn dc_get_abs_path(
 }
 
 pub unsafe fn dc_file_exist(
-    mut context: &dc_context_t,
-    mut pathNfilename: *const libc::c_char,
+    context: &dc_context_t,
+    pathNfilename: *const libc::c_char,
 ) -> libc::c_int {
     let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
     if pathNfilename_abs.is_null() {
@@ -1427,8 +1418,8 @@ pub unsafe fn dc_copy_file(
 }
 
 pub unsafe fn dc_create_folder(
-    mut context: &dc_context_t,
-    mut pathNfilename: *const libc::c_char,
+    context: &dc_context_t,
+    pathNfilename: *const libc::c_char,
 ) -> libc::c_int {
     let mut success = 0;
     let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
@@ -1542,16 +1533,16 @@ pub unsafe fn dc_read_file(
 }
 
 pub unsafe fn dc_get_fine_pathNfilename(
-    mut context: &dc_context_t,
-    mut pathNfolder: *const libc::c_char,
-    mut desired_filenameNsuffix__: *const libc::c_char,
+    context: &dc_context_t,
+    pathNfolder: *const libc::c_char,
+    desired_filenameNsuffix__: *const libc::c_char,
 ) -> *mut libc::c_char {
     let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut pathNfolder_wo_slash: *mut libc::c_char;
-    let mut filenameNsuffix: *mut libc::c_char;
+    let pathNfolder_wo_slash: *mut libc::c_char;
+    let filenameNsuffix: *mut libc::c_char;
     let mut basename: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut dotNSuffix: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut now: time_t = time(0 as *mut time_t);
+    let now: time_t = time(0 as *mut time_t);
     let mut i: libc::c_int = 0i32;
     pathNfolder_wo_slash = dc_strdup(pathNfolder);
     dc_ensure_no_slash(pathNfolder_wo_slash);
@@ -1561,7 +1552,7 @@ pub unsafe fn dc_get_fine_pathNfilename(
     while i < 1000i32 {
         /*no deadlocks, please*/
         if 0 != i {
-            let mut idx: time_t = if i < 100i32 {
+            let idx: time_t = if i < 100i32 {
                 i as libc::c_long
             } else {
                 now + i as libc::c_long
@@ -1599,10 +1590,7 @@ pub unsafe fn dc_get_fine_pathNfilename(
 }
 
 // TODO should return bool /rtn
-pub unsafe fn dc_is_blobdir_path(
-    mut context: &dc_context_t,
-    mut path: *const libc::c_char,
-) -> libc::c_int {
+pub unsafe fn dc_is_blobdir_path(context: &dc_context_t, path: *const libc::c_char) -> libc::c_int {
     if strncmp(path, context.get_blobdir(), strlen(context.get_blobdir())) == 0i32
         || strncmp(path, b"$BLOBDIR\x00" as *const u8 as *const libc::c_char, 8) == 0i32
     {
@@ -1612,7 +1600,7 @@ pub unsafe fn dc_is_blobdir_path(
     0
 }
 
-pub unsafe fn dc_make_rel_path(mut context: &dc_context_t, mut path: *mut *mut libc::c_char) {
+pub unsafe fn dc_make_rel_path(context: &dc_context_t, path: *mut *mut libc::c_char) {
     if path.is_null() || (*path).is_null() {
         return;
     }
@@ -1627,8 +1615,8 @@ pub unsafe fn dc_make_rel_path(mut context: &dc_context_t, mut path: *mut *mut l
 
 // TODO should return bool /rtn
 pub unsafe fn dc_make_rel_and_copy(
-    mut context: &dc_context_t,
-    mut path: *mut *mut libc::c_char,
+    context: &dc_context_t,
+    path: *mut *mut libc::c_char,
 ) -> libc::c_int {
     let mut success: libc::c_int = 0i32;
     let mut filename: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -1672,9 +1660,9 @@ mod tests {
     #[test]
     fn test_dc_ltrim() {
         unsafe {
-            let mut html: *const libc::c_char =
+            let html: *const libc::c_char =
                 b"\r\r\nline1<br>\r\n\r\n\r\rline2\n\r\x00" as *const u8 as *const libc::c_char;
-            let mut out: *mut libc::c_char = strndup(html, strlen(html) as libc::c_ulong);
+            let out: *mut libc::c_char = strndup(html, strlen(html) as libc::c_ulong);
 
             dc_ltrim(out);
 
@@ -1688,9 +1676,9 @@ mod tests {
     #[test]
     fn test_dc_rtrim() {
         unsafe {
-            let mut html: *const libc::c_char =
+            let html: *const libc::c_char =
                 b"\r\r\nline1<br>\r\n\r\n\r\rline2\n\r\x00" as *const u8 as *const libc::c_char;
-            let mut out: *mut libc::c_char = strndup(html, strlen(html) as libc::c_ulong);
+            let out: *mut libc::c_char = strndup(html, strlen(html) as libc::c_ulong);
 
             dc_rtrim(out);
 
@@ -1704,9 +1692,9 @@ mod tests {
     #[test]
     fn test_dc_trim() {
         unsafe {
-            let mut html: *const libc::c_char =
+            let html: *const libc::c_char =
                 b"\r\r\nline1<br>\r\n\r\n\r\rline2\n\r\x00" as *const u8 as *const libc::c_char;
-            let mut out: *mut libc::c_char = strndup(html, strlen(html) as libc::c_ulong);
+            let out: *mut libc::c_char = strndup(html, strlen(html) as libc::c_ulong);
 
             dc_trim(out);
 
diff --git a/src/lib.rs b/src/lib.rs
index dbae66233..be01f7b5b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,7 +3,6 @@
     non_camel_case_types,
     non_snake_case,
     non_upper_case_globals,
-    unused_mut,
     unused_attributes,
     non_upper_case_globals,
     non_camel_case_types,
@@ -29,6 +28,7 @@ pub mod dc_log;
 mod pgp;
 
 pub mod dc_aheader;
+
 pub mod dc_apeerstate;
 pub mod dc_array;
 pub mod dc_chat;