Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-04-26 18:06:35 +03:00
Code Issues Packages Projects Releases Wiki Activity

Fix some clippy warnings

Browse Source
This commit is contained in:
Dmitry Bogatov
2019-08-13 20:10:18 +00:00
committed by holger krekel
parent e05944c6cb
commit 8342b29618
20 changed files with 200 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/chatlist.rs
View File

@@ -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 {

3
src/config.rs
View File

@@ -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),
}

2
src/constants.rs
View File

@@ -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)]

18
src/context.rs
View File

@@ -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 {

53
src/dc_chat.rs
View File

@@ -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,
)
};

19
src/dc_configure.rs
View File

@@ -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<dc_loginparam_t> {
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;
}

3
src/dc_dehtml.rs
View File

@@ -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,

107
src/dc_e2ee.rs
View File

@@ -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.

45
src/dc_imex.rs
View File

@@ -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<std::path::PathBuf> = 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,

49
src/dc_job.rs
View File

@@ -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::<Result<Vec<dc_job_t>, _>>()
.map_err(Into::into);
res
jobs.collect::<Result<Vec<dc_job_t>, _>>()
.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(

4
src/dc_location.rs
View File

@@ -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)
},

6
src/dc_mimeparser.rs
View File

@@ -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)]

12
src/dc_msg.rs
View File

@@ -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) {

15
src/dc_receive_imf.rs
View File

@@ -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.

4
src/dc_strencode.rs
View File

@@ -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) {

19
src/dc_tools.rs
View File

@@ -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;
}

12
src/imap.rs
View File

@@ -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<IdleHandle> {
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;

4
src/key.rs
View File

@@ -89,7 +89,7 @@ impl Key {
}
pub fn from_slice(bytes: &[u8], key_type: KeyType) -> Option<Self> {
if 0 == bytes.len() {
if bytes.is_empty() {
return None;
}
let res: Result<Key, _> = 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()
}
}
}

13
src/pgp.rs
View File

@@ -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<str>) -> 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,

12
src/sql.rs
View File

@@ -286,7 +286,7 @@ impl Sql {
fn table_exists(conn: &Connection, name: impl AsRef<str>) -> Result<bool> {
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;
}