diff --git a/src/chatlist.rs b/src/chatlist.rs index 018aff4ab..c675f3b64 100644 --- a/src/chatlist.rs +++ b/src/chatlist.rs @@ -7,6 +7,7 @@ use crate::dc_msg::*; use crate::dc_tools::*; use crate::error::Result; use crate::stock::StockMessage; +use std::ptr; /// An object representing a single chatlist in memory. /// @@ -290,7 +291,7 @@ impl<'a> Chatlist<'a> { }; if (*chat).id == DC_CHAT_ID_ARCHIVED_LINK as u32 { - (*ret).text2 = dc_strdup(0 as *const libc::c_char) + (*ret).text2 = dc_strdup(ptr::null()) } else if lastmsg.is_null() || (*lastmsg).from_id == DC_CONTACT_ID_UNDEFINED as u32 { (*ret).text2 = self.context.stock_str(StockMessage::NoMessages).strdup(); } else { diff --git a/src/config.rs b/src/config.rs index 459d0f949..839af5cfb 100644 --- a/src/config.rs +++ b/src/config.rs @@ -120,8 +120,7 @@ impl Context { value }; - let ret = self.sql.set_config(self, key, val); - ret + self.sql.set_config(self, key, val) } _ => self.sql.set_config(self, key, value), } diff --git a/src/constants.rs b/src/constants.rs index dfa5960b1..6f22595e9 100644 --- a/src/constants.rs +++ b/src/constants.rs @@ -2,7 +2,7 @@ #![allow(non_camel_case_types)] use deltachat_derive::*; -pub const DC_VERSION_STR: &'static [u8; 14] = b"1.0.0-alpha.3\x00"; +pub const DC_VERSION_STR: &[u8; 14] = b"1.0.0-alpha.3\x00"; #[repr(u8)] #[derive(Debug, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, ToSql, FromSql)] diff --git a/src/context.rs b/src/context.rs index 1a70562ae..942a525f6 100644 --- a/src/context.rs +++ b/src/context.rs @@ -19,6 +19,7 @@ use crate::smtp::*; use crate::sql::Sql; use crate::types::*; use crate::x::*; +use std::ptr; pub struct Context { pub userdata: *mut libc::c_void, @@ -140,7 +141,7 @@ pub fn dc_context_new( })), userdata, cb, - os_name: os_name, + os_name, running_state: Arc::new(RwLock::new(Default::default())), sql: Sql::new(), smtp: Arc::new(Mutex::new(Smtp::new())), @@ -201,7 +202,7 @@ unsafe fn cb_precheck_imf( ) -> libc::c_int { let mut rfc724_mid_exists: libc::c_int = 0i32; let msg_id: uint32_t; - let mut old_server_folder: *mut libc::c_char = 0 as *mut libc::c_char; + let mut old_server_folder: *mut libc::c_char = ptr::null_mut(); let mut old_server_uid: uint32_t = 0i32 as uint32_t; let mut mark_seen: libc::c_int = 0i32; msg_id = dc_rfc724_mid_exists( @@ -240,7 +241,7 @@ unsafe fn cb_precheck_imf( } } free(old_server_folder as *mut libc::c_void); - return rfc724_mid_exists; + rfc724_mid_exists } fn cb_set_config(context: &Context, key: &str, value: Option<&str>) { @@ -282,17 +283,14 @@ pub unsafe fn dc_close(context: &Context) { context.sql.close(context); let mut dbfile = context.dbfile.write().unwrap(); free(*dbfile as *mut libc::c_void); - *dbfile = 0 as *mut libc::c_char; + *dbfile = ptr::null_mut(); let mut blobdir = context.blobdir.write().unwrap(); free(*blobdir as *mut libc::c_void); - *blobdir = 0 as *mut libc::c_char; + *blobdir = ptr::null_mut(); } pub unsafe fn dc_is_open(context: &Context) -> libc::c_int { - match context.sql.is_open() { - true => 1, - false => 0, - } + context.sql.is_open() as libc::c_int } pub unsafe fn dc_get_userdata(context: &mut Context) -> *mut libc::c_void { @@ -305,7 +303,7 @@ pub unsafe fn dc_open(context: &Context, dbfile: &str, blobdir: Option<&str>) -> return false; } *context.dbfile.write().unwrap() = dbfile.strdup(); - if blobdir.is_some() && blobdir.unwrap().len() > 0 { + if blobdir.is_some() && !blobdir.unwrap().is_empty() { let dir = dc_ensure_no_slash_safe(blobdir.unwrap()).strdup(); *context.blobdir.write().unwrap() = dir; } else { diff --git a/src/dc_chat.rs b/src/dc_chat.rs index b815f7a82..ba879ed03 100644 --- a/src/dc_chat.rs +++ b/src/dc_chat.rs @@ -13,6 +13,7 @@ use crate::sql::{self, Sql}; use crate::stock::StockMessage; use crate::types::*; use crate::x::*; +use std::ptr; /** * @class dc_chat_t @@ -92,11 +93,11 @@ pub unsafe fn dc_chat_empty(mut chat: *mut Chat) { return; } free((*chat).name as *mut libc::c_void); - (*chat).name = 0 as *mut libc::c_char; + (*chat).name = ptr::null_mut(); (*chat).type_0 = 0i32; (*chat).id = 0i32 as uint32_t; free((*chat).grpid as *mut libc::c_void); - (*chat).grpid = 0 as *mut libc::c_char; + (*chat).grpid = ptr::null_mut(); (*chat).blocked = 0i32; (*chat).gossiped_timestamp = 0; (*chat).param = Params::new(); @@ -216,7 +217,7 @@ pub unsafe fn dc_create_chat_by_contact_id(context: &Context, contact_id: uint32 contact_id, 0i32, &mut chat_id, - 0 as *mut libc::c_int, + ptr::null_mut(), ); if 0 != chat_id { send_event = 1; @@ -333,11 +334,11 @@ pub unsafe fn dc_get_chat_id_by_contact_id(context: &Context, contact_id: uint32 let mut chat_id: uint32_t = 0i32 as uint32_t; let mut chat_id_blocked: libc::c_int = 0i32; dc_lookup_real_nchat_by_contact_id(context, contact_id, &mut chat_id, &mut chat_id_blocked); - return if 0 != chat_id_blocked { + if 0 != chat_id_blocked { 0i32 as libc::c_uint } else { chat_id - }; + } } pub unsafe fn dc_prepare_msg<'a>( @@ -355,7 +356,7 @@ pub unsafe fn dc_prepare_msg<'a>( (*msg).chat_id as uintptr_t, (*msg).id as uintptr_t, ); - return msg_id; + msg_id } pub fn msgtype_has_file(msgtype: Viewtype) -> bool { @@ -421,11 +422,7 @@ unsafe fn prepare_msg_common<'a>( } else if !(*msg).param.exists(Param::MimeType) { let mut better_mime = std::ptr::null_mut(); - dc_msg_guess_msgtype_from_suffix( - pathNfilename, - 0 as *mut Viewtype, - &mut better_mime, - ); + dc_msg_guess_msgtype_from_suffix(pathNfilename, ptr::null_mut(), &mut better_mime); if !better_mime.is_null() { (*msg).param.set(Param::MimeType, as_str(better_mime)); @@ -477,12 +474,12 @@ unsafe fn prepare_msg_raw( let mut do_guarantee_e2ee: libc::c_int; let e2ee_enabled: libc::c_int; let mut OK_TO_CONTINUE = true; - let mut parent_rfc724_mid = 0 as *mut libc::c_char; - let mut parent_references = 0 as *mut libc::c_char; - let mut parent_in_reply_to = 0 as *mut libc::c_char; - let mut new_rfc724_mid = 0 as *mut libc::c_char; - let mut new_references = 0 as *mut libc::c_char; - let mut new_in_reply_to = 0 as *mut libc::c_char; + let mut parent_rfc724_mid = ptr::null_mut(); + let mut parent_references = ptr::null_mut(); + let mut parent_in_reply_to = ptr::null_mut(); + let mut new_rfc724_mid = ptr::null_mut(); + let mut new_references = ptr::null_mut(); + let mut new_in_reply_to = ptr::null_mut(); let mut msg_id = 0; let mut to_id = 0; let mut location_id = 0; @@ -508,7 +505,7 @@ unsafe fn prepare_msg_raw( if (*chat).type_0 == 120 || (*chat).type_0 == 130 { (*chat).grpid } else { - 0 as *mut libc::c_char + ptr::null_mut() }, from_c.as_ptr(), ); @@ -1052,12 +1049,12 @@ pub unsafe fn dc_get_draft(context: &Context, chat_id: uint32_t) -> *mut dc_msg_ } draft_msg_id = get_draft_msg_id(context, chat_id); if draft_msg_id == 0i32 as libc::c_uint { - return 0 as *mut dc_msg_t; + return ptr::null_mut(); } draft_msg = dc_msg_new_untyped(context); if !dc_msg_load_from_db(draft_msg, context, draft_msg_id) { dc_msg_unref(draft_msg); - return 0 as *mut dc_msg_t; + return ptr::null_mut(); } draft_msg @@ -1269,7 +1266,7 @@ pub unsafe fn dc_get_next_media( ) -> uint32_t { let mut ret_msg_id: uint32_t = 0i32 as uint32_t; 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 list: *mut dc_array_t = ptr::null_mut(); let mut i: libc::c_int; let cnt: libc::c_int; @@ -1438,11 +1435,11 @@ pub unsafe fn dc_get_chat(context: &Context, chat_id: uint32_t) -> *mut Chat { } if 0 != success { - return obj; + obj } else { dc_chat_unref(obj); - return 0 as *mut Chat; - }; + ptr::null_mut() + } } // handle group chats @@ -1852,7 +1849,7 @@ pub unsafe fn dc_set_chat_profile_image( let mut success: libc::c_int = 0i32; let chat: *mut Chat = 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; + let mut new_image_rel: *mut libc::c_char = ptr::null_mut(); if !(chat_id <= 9i32 as libc::c_uint) { if !(0i32 == real_group_exists(context, chat_id) || !dc_chat_load_from_db(chat, chat_id)) { if !(dc_is_contact_in_chat(context, chat_id, 1i32 as uint32_t) == 1i32) { @@ -2068,11 +2065,11 @@ pub unsafe fn dc_chat_get_subtitle(chat: *const Chat) -> *mut libc::c_char { .strdup(); } } - return if !ret.is_null() { + if !ret.is_null() { ret } else { dc_strdup(b"Err\x00" as *const u8 as *const libc::c_char) - }; + } } pub fn dc_get_chat_contact_cnt(context: &Context, chat_id: u32) -> libc::c_int { @@ -2223,7 +2220,7 @@ pub fn dc_add_device_msg(context: &Context, chat_id: uint32_t, text: *const libc } let rfc724_mid = unsafe { dc_create_outgoing_rfc724_mid( - 0 as *const libc::c_char, + ptr::null(), b"@device\x00" as *const u8 as *const libc::c_char, ) }; diff --git a/src/dc_configure.rs b/src/dc_configure.rs index 7043519d6..744c559e0 100644 --- a/src/dc_configure.rs +++ b/src/dc_configure.rs @@ -12,6 +12,7 @@ use crate::oauth2::*; use crate::param::Params; use crate::types::*; use crate::x::*; +use std::ptr; macro_rules! progress { ($context:tt, $progress:expr) => { @@ -729,7 +730,7 @@ unsafe fn moz_autoconfigure( starttag_cb: None, endtag_cb: None, text_cb: None, - userdata: 0 as *mut libc::c_void, + userdata: ptr::null_mut(), }; dc_saxparser_init( &mut saxparser, @@ -791,12 +792,12 @@ unsafe fn moz_autoconfigure_text_cb( match (*moz_ac).tag_config { 10 => { (*moz_ac).out.mail_server = to_string(val); - val = 0 as *mut libc::c_char + val = ptr::null_mut(); } 11 => (*moz_ac).out.mail_port = dc_atoi_null_is_0(val), 12 => { (*moz_ac).out.mail_user = to_string(val); - val = 0 as *mut libc::c_char + val = ptr::null_mut(); } 13 => { if strcasecmp(val, b"ssl\x00" as *const u8 as *const libc::c_char) == 0 { @@ -815,12 +816,12 @@ unsafe fn moz_autoconfigure_text_cb( match (*moz_ac).tag_config { 10 => { (*moz_ac).out.send_server = to_string(val); - val = 0 as *mut libc::c_char + val = ptr::null_mut(); } 11 => (*moz_ac).out.send_port = as_str(val).parse().unwrap_or_default(), 12 => { (*moz_ac).out.send_user = to_string(val); - val = 0 as *mut libc::c_char + val = ptr::null_mut(); } 13 => { if strcasecmp(val, b"ssl\x00" as *const u8 as *const libc::c_char) == 0 { @@ -924,7 +925,7 @@ unsafe fn outlk_autodiscover( url__: &str, param_in: &dc_loginparam_t, ) -> Option { - let mut xml_raw: *mut libc::c_char = 0 as *mut libc::c_char; + let mut xml_raw: *mut libc::c_char = ptr::null_mut(); let mut url = url__.strdup(); let mut outlk_ad = outlk_autodiscover_t { in_0: param_in, @@ -932,8 +933,8 @@ unsafe fn outlk_autodiscover( out_imap_set: 0, out_smtp_set: 0, tag_config: 0, - config: [0 as *mut libc::c_char; 6], - redirect: 0 as *mut libc::c_char, + config: [ptr::null_mut(); 6], + redirect: ptr::null_mut(), }; let ok_to_continue; let mut i = 0; @@ -980,7 +981,7 @@ unsafe fn outlk_autodiscover( outlk_clean_config(&mut outlk_ad); free(xml_raw as *mut libc::c_void); - xml_raw = 0 as *mut libc::c_char; + xml_raw = ptr::null_mut(); i += 1; } diff --git a/src/dc_dehtml.rs b/src/dc_dehtml.rs index de8fa5767..f69631cec 100644 --- a/src/dc_dehtml.rs +++ b/src/dc_dehtml.rs @@ -3,6 +3,7 @@ use lazy_static::lazy_static; use crate::dc_saxparser::*; use crate::dc_tools::*; use crate::x::*; +use std::ptr; lazy_static! { static ref LINE_RE: regex::Regex = regex::Regex::new(r"(\r?\n)+").unwrap(); @@ -38,7 +39,7 @@ pub unsafe fn dc_dehtml(buf_terminated: *mut libc::c_char) -> *mut libc::c_char starttag_cb: None, endtag_cb: None, text_cb: None, - userdata: 0 as *mut libc::c_void, + userdata: ptr::null_mut(), }; dc_saxparser_init( &mut saxparser, diff --git a/src/dc_e2ee.rs b/src/dc_e2ee.rs index a3581adf6..90176df2a 100644 --- a/src/dc_e2ee.rs +++ b/src/dc_e2ee.rs @@ -2,6 +2,7 @@ use std::collections::HashSet; use std::ffi::CStr; +use std::ptr; use std::str::FromStr; use mmime::clist::*; @@ -145,7 +146,7 @@ pub unsafe fn dc_e2ee_encrypt( iter1 = if !iter1.is_null() { (*iter1).next } else { - 0 as *mut clistcell + ptr::null_mut() } } } @@ -170,19 +171,19 @@ pub unsafe fn dc_e2ee_encrypt( mailprivacy_prepare_mime(in_out_message); 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; + (*part_to_encrypt).mm_parent = ptr::null_mut(); 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 message_to_encrypt: *mut mailmime = mailmime_new( MAILMIME_MESSAGE as libc::c_int, - 0 as *const libc::c_char, + ptr::null(), 0i32 as size_t, mailmime_fields_new_empty(), mailmime_get_content_message(), - 0 as *mut mailmime_data, - 0 as *mut mailmime_data, - 0 as *mut mailmime_data, - 0 as *mut clist, + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), imffields_encrypted, part_to_encrypt, ); @@ -214,7 +215,7 @@ pub unsafe fn dc_e2ee_encrypt( let field: *mut mailimf_field = (if !cur.is_null() { (*cur).data } else { - 0 as *mut libc::c_void + ptr::null_mut() }) as *mut mailimf_field; if !field.is_null() { @@ -265,28 +266,28 @@ pub unsafe fn dc_e2ee_encrypt( imffields_unprotected, mailimf_field_new( MAILIMF_FIELD_SUBJECT as libc::c_int, - 0 as *mut mailimf_return, - 0 as *mut mailimf_orig_date, - 0 as *mut mailimf_from, - 0 as *mut mailimf_sender, - 0 as *mut mailimf_to, - 0 as *mut mailimf_cc, - 0 as *mut mailimf_bcc, - 0 as *mut mailimf_message_id, - 0 as *mut mailimf_orig_date, - 0 as *mut mailimf_from, - 0 as *mut mailimf_sender, - 0 as *mut mailimf_reply_to, - 0 as *mut mailimf_to, - 0 as *mut mailimf_cc, - 0 as *mut mailimf_bcc, - 0 as *mut mailimf_message_id, - 0 as *mut mailimf_in_reply_to, - 0 as *mut mailimf_references, + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), subject, - 0 as *mut mailimf_comments, - 0 as *mut mailimf_keywords, - 0 as *mut mailimf_optional_field, + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), ), ); clist_insert_after( @@ -314,7 +315,7 @@ pub unsafe fn dc_e2ee_encrypt( /* create MIME-structure that will contain the encrypted text */ let mut encrypted_part: *mut mailmime = new_data_part( - 0 as *mut libc::c_void, + ptr::null_mut(), 0i32 as size_t, b"multipart/encrypted\x00" as *const u8 as *const libc::c_char as *mut libc::c_char, @@ -400,7 +401,7 @@ unsafe fn new_data_part( 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; + encoding = ptr::null_mut(); if default_content_type.is_null() { content_type_str = b"application/octet-stream\x00" as *const u8 as *const libc::c_char as *mut libc::c_char @@ -435,7 +436,7 @@ unsafe fn new_data_part( } else { encoding_type = default_encoding } - encoding = mailmime_mechanism_new(encoding_type, 0 as *mut libc::c_char); + encoding = mailmime_mechanism_new(encoding_type, ptr::null_mut()); if encoding.is_null() { ok_to_continue = false; } @@ -443,10 +444,10 @@ unsafe fn new_data_part( if ok_to_continue { mime_fields = mailmime_fields_new_with_data( encoding, - 0 as *mut libc::c_char, - 0 as *mut libc::c_char, - 0 as *mut mailmime_disposition, - 0 as *mut mailmime_language, + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), ); if mime_fields.is_null() { ok_to_continue = false; @@ -476,7 +477,7 @@ unsafe fn new_data_part( mailmime_content_free(content); } } - return 0 as *mut mailmime; + ptr::null_mut() } /// Load public key from database or generate a new one. @@ -539,10 +540,10 @@ pub unsafe fn dc_e2ee_decrypt( /*just a pointer into mailmime structure, must not be freed*/ let imffields: *mut mailimf_fields = mailmime_find_mailimf_fields(in_out_message); let mut message_time = 0; - let mut from: *mut libc::c_char = 0 as *mut libc::c_char; + let mut from: *mut libc::c_char = ptr::null_mut(); let mut private_keyring = Keyring::default(); let mut public_keyring_for_validate = Keyring::default(); - let mut gossip_headers: *mut mailimf_fields = 0 as *mut mailimf_fields; + let mut gossip_headers: *mut mailimf_fields = ptr::null_mut(); if !(in_out_message.is_null() || imffields.is_null()) { let mut field: *mut mailimf_field = mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int); @@ -646,7 +647,7 @@ unsafe fn update_gossip_peerstates( let field: *mut mailimf_field = (if !cur1.is_null() { (*cur1).data } else { - 0 as *mut libc::c_void + ptr::null_mut() }) as *mut mailimf_field; if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int { let optional_field: *const mailimf_optional_field = @@ -698,7 +699,7 @@ unsafe fn update_gossip_peerstates( cur1 = if !cur1.is_null() { (*cur1).next } else { - 0 as *mut clistcell + ptr::null_mut() } } @@ -731,7 +732,7 @@ unsafe fn decrypt_recursive( { cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first; while !cur.is_null() { - let mut decrypted_mime: *mut mailmime = 0 as *mut mailmime; + let mut decrypted_mime: *mut mailmime = ptr::null_mut(); if 0 != decrypt_part( context, (if !cur.is_null() { @@ -746,7 +747,7 @@ unsafe fn decrypt_recursive( ) { if (*ret_gossip_headers).is_null() && ret_valid_signatures.len() > 0 { let mut dummy: size_t = 0i32 as size_t; - let mut test: *mut mailimf_fields = 0 as *mut mailimf_fields; + let mut test: *mut mailimf_fields = ptr::null_mut(); if mailimf_envelope_and_optional_fields_parse( (*decrypted_mime).mm_mime_start, (*decrypted_mime).mm_length, @@ -777,7 +778,7 @@ unsafe fn decrypt_recursive( (if !cur.is_null() { (*cur).data } else { - 0 as *mut libc::c_void + ptr::null_mut() }) as *mut mailmime, private_keyring, public_keyring_for_validate, @@ -790,7 +791,7 @@ unsafe fn decrypt_recursive( cur = if !cur.is_null() { (*cur).next } else { - 0 as *mut clistcell + ptr::null_mut() } } } @@ -825,12 +826,12 @@ unsafe fn decrypt_part( 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; + let mut transfer_decoding_buffer: *mut libc::c_char = ptr::null_mut(); /* must not be free()'d */ - let mut decoded_data: *const libc::c_char = 0 as *const libc::c_char; + let mut decoded_data: *const libc::c_char = ptr::null_mut(); let mut decoded_data_bytes: size_t = 0i32 as size_t; let mut sth_decrypted: libc::c_int = 0i32; - *ret_decrypted_mime = 0 as *mut mailmime; + *ret_decrypted_mime = ptr::null_mut(); mime_data = (*mime).mm_data.mm_single; /* MAILMIME_DATA_FILE indicates, the data is in a file; AFAIK this is not used on parsing */ if !((*mime_data).dt_type != MAILMIME_DATA_TEXT as libc::c_int @@ -844,7 +845,7 @@ unsafe fn decrypt_part( let field: *mut mailmime_field = (if !cur.is_null() { (*cur).data } else { - 0 as *mut libc::c_void + ptr::null_mut() }) as *mut mailmime_field; if !field.is_null() { if (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int @@ -856,7 +857,7 @@ unsafe fn decrypt_part( cur = if !cur.is_null() { (*cur).next } else { - 0 as *mut clistcell + ptr::null_mut() } } } @@ -912,7 +913,7 @@ unsafe fn decrypt_part( let plain_buf = plain.as_ptr() as *const libc::c_char; let mut index: size_t = 0i32 as size_t; - let mut decrypted_mime: *mut mailmime = 0 as *mut mailmime; + let mut decrypted_mime: *mut mailmime = ptr::null_mut(); if mailmime_parse( plain_buf as *const _, plain_bytes, @@ -1010,7 +1011,7 @@ unsafe fn contains_report(mime: *mut mailmime) -> libc::c_int { (if !cur.is_null() { (*cur).data } else { - 0 as *mut libc::c_void + ptr::null_mut() }) as *mut mailmime, ) { return 1i32; @@ -1033,7 +1034,7 @@ unsafe fn contains_report(mime: *mut mailmime) -> libc::c_int { /* frees data referenced by "mailmime" but not freed by mailmime_free(). After calling this function, in_out_message cannot be used any longer! */ pub unsafe fn dc_e2ee_thanks(helper: &mut dc_e2ee_helper_t) { free(helper.cdata_to_free); - helper.cdata_to_free = 0 as *mut libc::c_void; + helper.cdata_to_free = ptr::null_mut(); } /// Ensures a private key exists for the configured user. diff --git a/src/dc_imex.rs b/src/dc_imex.rs index e45a634c6..02f6d4d2a 100644 --- a/src/dc_imex.rs +++ b/src/dc_imex.rs @@ -1,4 +1,5 @@ use std::ffi::CString; +use std::ptr; use mmime::mailmime_content::*; use mmime::mmapstring::*; @@ -61,7 +62,7 @@ pub unsafe fn dc_imex_has_backup( "Backup check: Cannot open directory \"{}\".\x00", dir_name.display(), ); - return 0 as *mut libc::c_char; + return ptr::null_mut(); } let mut newest_backup_time = 0; let mut newest_backup_path: Option = None; @@ -100,8 +101,8 @@ pub unsafe fn dc_imex_has_backup( } pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char { - let mut setup_file_name: *mut libc::c_char = 0 as *mut libc::c_char; - let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t; + let mut setup_file_name: *mut libc::c_char = ptr::null_mut(); + let mut msg: *mut dc_msg_t = ptr::null_mut(); if dc_alloc_ongoing(context) == 0 { return std::ptr::null_mut(); } @@ -159,7 +160,7 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char { let msg_id = dc_send_msg(context, chat_id, msg); if msg_id != 0 { dc_msg_unref(msg); - msg = 0 as *mut dc_msg_t; + msg = ptr::null_mut(); info!(context, 0, "Wait for setup message being sent ...",); loop { if context @@ -285,12 +286,12 @@ pub unsafe fn dc_continue_key_transfer( 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; - let mut filename: *mut libc::c_char = 0 as *mut libc::c_char; - let mut filecontent: *mut libc::c_char = 0 as *mut libc::c_char; + let mut msg: *mut dc_msg_t = ptr::null_mut(); + let mut filename: *mut libc::c_char = ptr::null_mut(); + let mut filecontent: *mut libc::c_char = ptr::null_mut(); let mut filebytes: size_t = 0i32 as size_t; - let mut armored_key: *mut libc::c_char = 0 as *mut libc::c_char; - let mut norm_sc: *mut libc::c_char = 0 as *mut libc::c_char; + let mut armored_key: *mut libc::c_char = ptr::null_mut(); + let mut norm_sc: *mut libc::c_char = ptr::null_mut(); if !(msg_id <= 9i32 as libc::c_uint || setup_code.is_null()) { msg = dc_get_msg(context, msg_id); if msg.is_null() @@ -423,19 +424,19 @@ pub unsafe fn dc_decrypt_setup_file( filecontent: *const libc::c_char, ) -> *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; + let mut fc_headerline: *const libc::c_char = ptr::null(); + let mut fc_base64: *const libc::c_char = ptr::null(); + let mut binary: *mut libc::c_char = ptr::null_mut(); let mut binary_bytes: size_t = 0i32 as size_t; let mut indx: size_t = 0i32 as size_t; - let mut payload: *mut libc::c_char = 0 as *mut libc::c_char; + let mut payload: *mut libc::c_char = ptr::null_mut(); fc_buf = dc_strdup(filecontent); if dc_split_armored_data( fc_buf, &mut fc_headerline, - 0 as *mut *const libc::c_char, - 0 as *mut *const libc::c_char, + ptr::null_mut(), + ptr::null_mut(), &mut fc_base64, ) && !fc_headerline.is_null() && strcmp( @@ -479,7 +480,7 @@ pub unsafe fn dc_normalize_setup_code( in_0: *const libc::c_char, ) -> *mut libc::c_char { if in_0.is_null() { - return 0 as *mut libc::c_char; + return ptr::null_mut(); } let mut out = String::new(); let mut outlen; @@ -926,16 +927,16 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) -> Maybe we should make the "default" key handlong also a little bit smarter (currently, the last imported key is the standard key unless it contains the string "legacy" in its name) */ let mut imported_cnt: libc::c_int = 0; - let mut suffix: *mut libc::c_char = 0 as *mut libc::c_char; - let mut path_plus_name: *mut libc::c_char = 0 as *mut libc::c_char; + let mut suffix: *mut libc::c_char = ptr::null_mut(); + let mut path_plus_name: *mut libc::c_char = ptr::null_mut(); let mut set_default: libc::c_int; - let mut buf: *mut libc::c_char = 0 as *mut libc::c_char; + let mut buf: *mut libc::c_char = ptr::null_mut(); let mut buf_bytes: size_t = 0 as size_t; // a pointer inside buf, MUST NOT be free()'d let mut private_key: *const libc::c_char; - let mut buf2: *mut libc::c_char = 0 as *mut libc::c_char; + let mut buf2: *mut libc::c_char = ptr::null_mut(); // a pointer inside buf2, MUST NOT be free()'d - let mut buf2_headerline: *const libc::c_char = 0 as *const libc::c_char; + let mut buf2_headerline: *const libc::c_char = ptr::null_mut(); if !dir_name.is_null() { let dir = std::path::Path::new(as_str(dir_name)); let dir_handle = std::fs::read_dir(dir); @@ -970,7 +971,7 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) -> ); info!(context, 0, "Checking: {}", as_str(path_plus_name)); free(buf as *mut libc::c_void); - buf = 0 as *mut libc::c_char; + buf = ptr::null_mut(); if 0 == dc_read_file( context, path_plus_name, diff --git a/src/dc_job.rs b/src/dc_job.rs index 09224a7ec..e512032ea 100644 --- a/src/dc_job.rs +++ b/src/dc_job.rs @@ -1,6 +1,7 @@ use mmime::mmapstring::*; use std::ffi::CStr; +use std::ptr; use std::time::Duration; use rand::{thread_rng, Rng}; @@ -101,10 +102,8 @@ unsafe fn dc_job_perform(context: &Context, thread: libc::c_int, probe_network: Ok(job) }, |jobs| { - let res = jobs - .collect::, _>>() - .map_err(Into::into); - res + jobs.collect::, _>>() + .map_err(Into::into) }, ); match jobs { @@ -294,7 +293,7 @@ unsafe fn dc_suspend_smtp_thread(context: &Context, suspend: bool) { unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) { let ok_to_continue; let mut filename: *mut libc::c_char = 0 as *mut libc::c_char; - let mut buf: *mut libc::c_void = 0 as *mut libc::c_void; + let mut buf: *mut libc::c_void = ptr::null_mut(); let mut buf_bytes: size_t = 0i32 as size_t; /* connect to SMTP server, if not yet done */ @@ -303,7 +302,7 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) { let connected = context.smtp.lock().unwrap().connect(context, &loginparam); if !connected { - dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char); + dc_job_try_again_later(job, 3i32, ptr::null()); ok_to_continue = false; } else { ok_to_continue = true; @@ -414,7 +413,7 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) { if !inbox.is_connected() { connect_to_inbox(context, &inbox); if !inbox.is_connected() { - dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char); + dc_job_try_again_later(job, 3i32, ptr::null()); ok_to_continue = false; } else { ok_to_continue = true; @@ -446,7 +445,7 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) { ) as libc::c_uint { 1 => { - dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char); + dc_job_try_again_later(job, 3i32, ptr::null()); } 3 => { dc_update_server_uid(context, (*msg).rfc724_mid, &dest_folder, dest_uid); @@ -486,7 +485,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_ if !inbox.is_connected() { connect_to_inbox(context, &inbox); if !inbox.is_connected() { - dc_job_try_again_later(job, 3, 0 as *const libc::c_char); + dc_job_try_again_later(job, 3, ptr::null()); ok_to_continue = false; } else { ok_to_continue = true; @@ -496,7 +495,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_ } if ok_to_continue { if inbox.set_seen(context, &folder, uid) == 0 { - dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char); + dc_job_try_again_later(job, 3i32, ptr::null()); } if 0 != job.param.get_int(Param::AlsoMove).unwrap_or_default() { if context @@ -526,7 +525,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_ if !inbox.is_connected() { connect_to_inbox(context, &inbox); if !inbox.is_connected() { - dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char); + dc_job_try_again_later(job, 3i32, ptr::null()); ok_to_continue = false; } else { ok_to_continue = true; @@ -540,7 +539,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_ match inbox.set_seen(context, server_folder, (*msg).server_uid) as libc::c_uint { 0 => {} 1 => { - dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char); + dc_job_try_again_later(job, 3i32, ptr::null()); } _ => { if 0 != (*msg).param.get_int(Param::WantsMdn).unwrap_or_default() @@ -570,25 +569,25 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_ } unsafe fn dc_send_mdn(context: &Context, 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, - selfstatus: 0 as *mut libc::c_char, - recipients_names: 0 as *mut clist, - recipients_addr: 0 as *mut clist, + from_addr: ptr::null_mut(), + from_displayname: ptr::null_mut(), + selfstatus: ptr::null_mut(), + recipients_names: ptr::null_mut(), + recipients_addr: ptr::null_mut(), timestamp: 0, - rfc724_mid: 0 as *mut libc::c_char, + rfc724_mid: ptr::null_mut(), loaded: DC_MF_NOTHING_LOADED, - msg: 0 as *mut dc_msg_t, - chat: 0 as *mut Chat, + msg: ptr::null_mut(), + chat: ptr::null_mut(), increation: 0, - in_reply_to: 0 as *mut libc::c_char, - references: 0 as *mut libc::c_char, + in_reply_to: ptr::null_mut(), + references: ptr::null_mut(), req_mdn: 0, - out: 0 as *mut MMAPString, + out: ptr::null_mut(), out_encrypted: 0, out_gossiped: 0, out_last_added_location_id: 0, - error: 0 as *mut libc::c_char, + error: ptr::null_mut(), context, }; dc_mimefactory_init(&mut mimefactory, context); @@ -671,7 +670,7 @@ unsafe fn dc_add_smtp_job( } free(recipients as *mut libc::c_void); free(pathNfilename as *mut libc::c_void); - return success; + success } pub unsafe fn dc_job_add( diff --git a/src/dc_location.rs b/src/dc_location.rs index 5e6e599ca..fa5f6cc0a 100644 --- a/src/dc_location.rs +++ b/src/dc_location.rs @@ -239,10 +239,10 @@ pub fn dc_get_locations( accuracy: row.get(3)?, timestamp: row.get(4)?, independent: row.get(5)?, - msg_id: msg_id, + msg_id, contact_id: row.get(7)?, chat_id: row.get(8)?, - marker: marker, + marker, }; Ok(loc) }, diff --git a/src/dc_mimeparser.rs b/src/dc_mimeparser.rs index 325c7f233..d0acb1364 100644 --- a/src/dc_mimeparser.rs +++ b/src/dc_mimeparser.rs @@ -1379,11 +1379,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known( free(file_suffix as *mut libc::c_void); free(desired_filename as *mut libc::c_void); free(raw_mime as *mut libc::c_void); - return if mimeparser.parts.len() > old_part_count { - 1 - } else { - 0 - }; + (mimeparser.parts.len() > old_part_count) as libc::c_int } #[allow(non_snake_case)] diff --git a/src/dc_msg.rs b/src/dc_msg.rs index 6dc03b482..c71adb469 100644 --- a/src/dc_msg.rs +++ b/src/dc_msg.rs @@ -419,11 +419,11 @@ pub unsafe fn dc_msg_get_timestamp(msg: *const dc_msg_t) -> i64 { if msg.is_null() { return 0; } - return if 0 != (*msg).timestamp_sent { + if 0 != (*msg).timestamp_sent { (*msg).timestamp_sent } else { (*msg).timestamp_sort - }; + } } pub fn dc_msg_load_from_db<'a>(msg: *mut dc_msg_t<'a>, context: &'a Context, id: u32) -> bool { @@ -1048,11 +1048,11 @@ pub unsafe fn dc_msg_get_setupcodebegin(msg: *const dc_msg_t) -> *mut libc::c_ch } free(filename as *mut libc::c_void); free(buf as *mut libc::c_void); - return if !ret.is_null() { + if !ret.is_null() { ret } else { dc_strdup(0 as *const libc::c_char) - }; + } } pub unsafe fn dc_msg_set_text(mut msg: *mut dc_msg_t, text: *const libc::c_char) { @@ -1201,9 +1201,9 @@ pub fn dc_update_msg_move_state( } fn msgstate_can_fail(state: i32) -> bool { - return DC_STATE_OUT_PREPARING == state + DC_STATE_OUT_PREPARING == state || DC_STATE_OUT_PENDING == state - || DC_STATE_OUT_DELIVERED == state; + || DC_STATE_OUT_DELIVERED == state } pub unsafe fn dc_set_msg_failed(context: &Context, msg_id: uint32_t, error: *const libc::c_char) { diff --git a/src/dc_receive_imf.rs b/src/dc_receive_imf.rs index bd15add0d..4ffe06fa4 100644 --- a/src/dc_receive_imf.rs +++ b/src/dc_receive_imf.rs @@ -8,6 +8,7 @@ use mmime::mailmime_types::*; use mmime::mmapstring::*; use mmime::other::*; use sha2::{Digest, Sha256}; +use std::ptr; use crate::constants::*; use crate::contact::*; @@ -772,7 +773,7 @@ unsafe fn lookup_field( ) -> Option<*const mailimf_field> { let field = dc_mimeparser_lookup_field(parser, name); if !field.is_null() && (*field).fld_type == typ as libc::c_int { - return Some(field); + Some(field) } else { None } @@ -1961,7 +1962,7 @@ unsafe fn dc_is_reply_to_known_message( } } } - return 0; + 0 } unsafe fn is_known_rfc724_mid_in_list(context: &Context, mid_list: *const clist) -> libc::c_int { @@ -1982,11 +1983,11 @@ unsafe fn is_known_rfc724_mid_in_list(context: &Context, mid_list: *const clist) cur = if !cur.is_null() { (*cur).next } else { - 0 as *mut clistcell + ptr::null_mut() } } } - return 0; + 0 } /// Check if a message is a reply to a known message (messenger or non-messenger). @@ -2039,7 +2040,7 @@ unsafe fn dc_is_reply_to_messenger_message( } } } - return 0; + 0 } unsafe fn is_msgrmsg_rfc724_mid_in_list(context: &Context, mid_list: *const clist) -> libc::c_int { @@ -2059,11 +2060,11 @@ unsafe fn is_msgrmsg_rfc724_mid_in_list(context: &Context, mid_list: *const clis cur = if !cur.is_null() { (*cur).next } else { - 0 as *mut clistcell + ptr::null_mut() } } } - return 0; + 0 } /// Check if a message is a reply to any messenger message. diff --git a/src/dc_strencode.rs b/src/dc_strencode.rs index 43396b6bc..26800471b 100644 --- a/src/dc_strencode.rs +++ b/src/dc_strencode.rs @@ -691,11 +691,11 @@ pub unsafe fn dc_decode_ext_header(to_decode: *const libc::c_char) -> *mut libc: } } free(charset as *mut libc::c_void); - return if !decoded.is_null() { + if !decoded.is_null() { decoded } else { dc_strdup(to_decode) - }; + } } unsafe fn print_hex(target: *mut libc::c_char, cur: *const libc::c_char) { diff --git a/src/dc_tools.rs b/src/dc_tools.rs index 7d9401615..857a4033a 100644 --- a/src/dc_tools.rs +++ b/src/dc_tools.rs @@ -12,6 +12,7 @@ use crate::dc_array::*; use crate::error::Error; use crate::types::*; use crate::x::*; +use std::ptr; const ELLIPSE: &'static str = "[...]"; @@ -67,11 +68,11 @@ pub unsafe fn dc_strdup(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() { + if !s.is_null() { dc_strdup(s) } else { - 0 as *mut libc::c_char - }; + ptr::null_mut() + } } pub unsafe fn dc_atoi_null_is_0(s: *const libc::c_char) -> libc::c_int { @@ -891,10 +892,10 @@ pub unsafe fn dc_get_filename(pathNfilename: *const libc::c_char) -> *mut libc:: } if !p.is_null() { p = p.offset(1isize); - return dc_strdup(p); + dc_strdup(p) } else { - return dc_strdup(pathNfilename); - }; + dc_strdup(pathNfilename) + } } // the case of the suffix is preserved @@ -1271,8 +1272,8 @@ pub unsafe fn dc_get_fine_pathNfilename( } pub unsafe fn dc_is_blobdir_path(context: &Context, path: *const libc::c_char) -> bool { - return strncmp(path, context.get_blobdir(), strlen(context.get_blobdir())) == 0 - || strncmp(path, b"$BLOBDIR\x00" as *const u8 as *const libc::c_char, 8) == 0; + strncmp(path, context.get_blobdir(), strlen(context.get_blobdir())) == 0 + || strncmp(path, b"$BLOBDIR\x00" as *const u8 as *const libc::c_char, 8) == 0 } pub unsafe fn dc_make_rel_path(context: &Context, path: *mut *mut libc::c_char) { @@ -1311,7 +1312,7 @@ pub unsafe fn dc_make_rel_and_copy(context: &Context, path: *mut *mut libc::c_ch { free(*path as *mut libc::c_void); *path = blobdir_path; - blobdir_path = 0 as *mut libc::c_char; + blobdir_path = ptr::null_mut(); dc_make_rel_path(context, path); success = true; } diff --git a/src/imap.rs b/src/imap.rs index 11a0a8bf8..1ea10efaa 100644 --- a/src/imap.rs +++ b/src/imap.rs @@ -18,9 +18,9 @@ pub const DC_ALREADY_DONE: usize = 2; pub const DC_RETRY_LATER: usize = 1; pub const DC_FAILED: usize = 0; -const PREFETCH_FLAGS: &'static str = "(UID ENVELOPE)"; -const BODY_FLAGS: &'static str = "(FLAGS BODY.PEEK[])"; -const FETCH_FLAGS: &'static str = "(FLAGS)"; +const PREFETCH_FLAGS: &str = "(UID ENVELOPE)"; +const BODY_FLAGS: &str = "(FLAGS BODY.PEEK[])"; +const FETCH_FLAGS: &str = "(FLAGS)"; #[repr(C)] pub struct Imap { @@ -260,8 +260,8 @@ impl Session { pub fn idle(&mut self) -> imap::error::Result { match self { - Session::Secure(i) => i.idle().map(|h| IdleHandle::Secure(h)), - Session::Insecure(i) => i.idle().map(|h| IdleHandle::Insecure(h)), + Session::Secure(i) => i.idle().map(IdleHandle::Secure), + Session::Insecure(i) => i.idle().map(IdleHandle::Insecure), } } @@ -539,7 +539,7 @@ impl Imap { let mut config = self.config.write().unwrap(); config.addr = addr.to_string(); config.imap_server = imap_server.to_string(); - config.imap_port = imap_port.into(); + config.imap_port = imap_port; config.imap_user = imap_user.to_string(); config.imap_pw = imap_pw.to_string(); config.server_flags = server_flags; diff --git a/src/key.rs b/src/key.rs index 6ed4b9eab..bb7ac3115 100644 --- a/src/key.rs +++ b/src/key.rs @@ -89,7 +89,7 @@ impl Key { } pub fn from_slice(bytes: &[u8], key_type: KeyType) -> Option { - if 0 == bytes.len() { + if bytes.is_empty() { return None; } let res: Result = match key_type { @@ -283,7 +283,7 @@ impl Key { Key::Public(_) => None, Key::Secret(k) => { let pub_key = k.public_key(); - pub_key.sign(k, || "".into()).map(|k| Key::Public(k)).ok() + pub_key.sign(k, || "".into()).map(Key::Public).ok() } } } diff --git a/src/pgp.rs b/src/pgp.rs index bfc68f281..eb36d95e1 100644 --- a/src/pgp.rs +++ b/src/pgp.rs @@ -2,6 +2,7 @@ use std::collections::HashSet; use std::convert::TryInto; use std::ffi::CStr; use std::io::Cursor; +use std::ptr; use pgp::composed::{ Deserializable, KeyType as PgpKeyType, Message, SecretKeyParamsBuilder, SignedPublicKey, @@ -29,19 +30,19 @@ pub unsafe fn dc_split_armored_data( let mut line: *mut libc::c_char = buf; let mut p1: *mut libc::c_char = buf; let mut p2: *mut libc::c_char; - let mut headerline: *mut libc::c_char = 0 as *mut libc::c_char; - let mut base64: *mut libc::c_char = 0 as *mut libc::c_char; + let mut headerline: *mut libc::c_char = ptr::null_mut(); + let mut base64: *mut libc::c_char = ptr::null_mut(); if !ret_headerline.is_null() { *ret_headerline = 0 as *const libc::c_char } if !ret_setupcodebegin.is_null() { - *ret_setupcodebegin = 0 as *const libc::c_char + *ret_setupcodebegin = ptr::null_mut(); } if !ret_preferencrypt.is_null() { - *ret_preferencrypt = 0 as *const libc::c_char + *ret_preferencrypt = ptr::null(); } if !ret_base64.is_null() { - *ret_base64 = 0 as *const libc::c_char + *ret_base64 = ptr::null(); } if !(buf.is_null() || ret_headerline.is_null()) { dc_remove_cr_chars(buf); @@ -143,7 +144,7 @@ pub fn dc_pgp_create_keypair(addr: impl AsRef) -> Option<(Key, Key)> { .key_type(PgpKeyType::Rsa(2048)) .can_create_certificates(true) .can_sign(true) - .primary_user_id(user_id.into()) + .primary_user_id(user_id) .passphrase(None) .preferred_symmetric_algorithms(smallvec![ SymmetricKeyAlgorithm::AES256, diff --git a/src/sql.rs b/src/sql.rs index 53deb9e82..e42a8ae09 100644 --- a/src/sql.rs +++ b/src/sql.rs @@ -286,7 +286,7 @@ impl Sql { fn table_exists(conn: &Connection, name: impl AsRef) -> Result { let mut exists = false; - conn.pragma(None, "table_info", &format!("{}", name.as_ref()), |_row| { + conn.pragma(None, "table_info", &name.as_ref().to_string(), |_row| { // will only be executed if the info was found exists = true; Ok(()) @@ -830,7 +830,7 @@ where &err, querystr.as_ref() ); - Err(err.into()) + Err(err) } } } @@ -1003,10 +1003,10 @@ pub fn housekeeping(context: &Context) { let name_f = entry.file_name(); let name_s = name_f.to_string_lossy(); - if is_file_in_use(&mut files_in_use, None, &name_s) - || is_file_in_use(&mut files_in_use, Some(".increation"), &name_s) - || is_file_in_use(&mut files_in_use, Some(".waveform"), &name_s) - || is_file_in_use(&mut files_in_use, Some("-preview.jpg"), &name_s) + if is_file_in_use(&files_in_use, None, &name_s) + || is_file_in_use(&files_in_use, Some(".increation"), &name_s) + || is_file_in_use(&files_in_use, Some(".waveform"), &name_s) + || is_file_in_use(&files_in_use, Some("-preview.jpg"), &name_s) { continue; }