Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-05-01 20:36:31 +03:00
Code Issues Packages Projects Releases Wiki Activity

Replace explicit casts from 0 to pointer with std::ptr::null

Browse Source
This commit is contained in:
Dmitry Bogatov
2019-08-27 19:12:03 +00:00
parent 22c1b34ebf
commit 2fe07e86c7
15 changed files with 223 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
examples/repl/cmdline.rs
View File

@@ -1,4 +1,5 @@
use std::ffi::CString; use std::ffi::CString;
use std::ptr;
use std::str::FromStr; use std::str::FromStr;
use deltachat::chat::{self, Chat}; use deltachat::chat::{self, Chat};
@@ -94,7 +95,7 @@ pub unsafe fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
unsafe fn dc_poke_eml_file(context: &Context, filename: *const libc::c_char) -> libc::c_int { unsafe fn dc_poke_eml_file(context: &Context, filename: *const libc::c_char) -> libc::c_int {
/* mainly for testing, may be called by dc_import_spec() */ /* mainly for testing, may be called by dc_import_spec() */
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut data: *mut libc::c_char = 0 as *mut libc::c_char; let mut data: *mut libc::c_char = ptr::null_mut();
let mut data_bytes: size_t = 0; let mut data_bytes: size_t = 0;
if !(dc_read_file( if !(dc_read_file(
context, context,
@@ -128,7 +129,7 @@ unsafe fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int
let ok_to_continue; let ok_to_continue;
let mut success: libc::c_int = 0; let mut success: libc::c_int = 0;
let real_spec: *mut libc::c_char; let real_spec: *mut libc::c_char;
let mut suffix: *mut libc::c_char = 0 as *mut libc::c_char; let mut suffix: *mut libc::c_char = ptr::null_mut();
let mut read_cnt: libc::c_int = 0; let mut read_cnt: libc::c_int = 0;
/* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */ /* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */
@@ -526,17 +527,17 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
} }
} }
"export-backup" => { "export-backup" => {
dc_imex(context, 11, context.get_blobdir(), 0 as *const libc::c_char); dc_imex(context, 11, context.get_blobdir(), ptr::null());
} }
"import-backup" => { "import-backup" => {
ensure!(!arg1.is_empty(), "Argument <backup-file> missing."); ensure!(!arg1.is_empty(), "Argument <backup-file> missing.");
dc_imex(context, 12, arg1_c, 0 as *const libc::c_char); dc_imex(context, 12, arg1_c, ptr::null());
} }
"export-keys" => { "export-keys" => {
dc_imex(context, 1, context.get_blobdir(), 0 as *const libc::c_char); dc_imex(context, 1, context.get_blobdir(), ptr::null());
} }
"import-keys" => { "import-keys" => {
dc_imex(context, 2, context.get_blobdir(), 0 as *const libc::c_char); dc_imex(context, 2, context.get_blobdir(), ptr::null());
} }
"export-setup" => { "export-setup" => {
let setup_code = dc_create_setup_code(context); let setup_code = dc_create_setup_code(context);
@@ -871,7 +872,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
Viewtype::File Viewtype::File
}, },
); );
dc_msg_set_file(&mut msg, arg1_c, 0 as *const libc::c_char); dc_msg_set_file(&mut msg, arg1_c, ptr::null());
dc_msg_set_text(&mut msg, arg2_c); dc_msg_set_text(&mut msg, arg2_c);
chat::send_msg(context, sel_chat.as_ref().unwrap().get_id(), &mut msg)?; chat::send_msg(context, sel_chat.as_ref().unwrap().get_id(), &mut msg)?;
} }

7
examples/repl/main.rs
View File

@@ -14,6 +14,7 @@ extern crate lazy_static;
extern crate rusqlite; extern crate rusqlite;
use std::borrow::Cow::{self, Borrowed, Owned}; use std::borrow::Cow::{self, Borrowed, Owned};
use std::ptr;
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, RwLock}; use std::sync::{Arc, Mutex, RwLock};
@@ -384,11 +385,7 @@ impl Highlighter for DcHelper {
impl Helper for DcHelper {} impl Helper for DcHelper {}
fn main_0(args: Vec<String>) -> Result<(), failure::Error> { fn main_0(args: Vec<String>) -> Result<(), failure::Error> {
let mut context = dc_context_new( let mut context = dc_context_new(Some(receive_event), ptr::null_mut(), Some("CLI".into()));
Some(receive_event),
0 as *mut libc::c_void,
Some("CLI".into()),
);
unsafe { dc_cmdline_skip_auth() }; unsafe { dc_cmdline_skip_auth() };

2
src/configure/auto_outlook.rs
View File

@@ -126,7 +126,7 @@ pub unsafe fn outlk_autodiscover(
unsafe fn outlk_clean_config(mut outlk_ad: *mut outlk_autodiscover_t) { unsafe fn outlk_clean_config(mut outlk_ad: *mut outlk_autodiscover_t) {
for i in 0..6 { for i in 0..6 {
free((*outlk_ad).config[i] as *mut libc::c_void); free((*outlk_ad).config[i] as *mut libc::c_void);
(*outlk_ad).config[i] = 0 as *mut libc::c_char; (*outlk_ad).config[i] = ptr::null_mut();
} }
} }

12
src/dc_e2ee.rs
View File

@@ -255,7 +255,7 @@ pub unsafe fn dc_e2ee_encrypt(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -738,7 +738,7 @@ unsafe fn decrypt_recursive(
(if !cur.is_null() { (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime, }) as *mut mailmime,
private_keyring, private_keyring,
public_keyring_for_validate, public_keyring_for_validate,
@@ -766,7 +766,7 @@ unsafe fn decrypt_recursive(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
*ret_has_unencrypted_parts = 1i32 *ret_has_unencrypted_parts = 1i32
@@ -1019,7 +1019,7 @@ unsafe fn contains_report(mime: *mut mailmime) -> libc::c_int {
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} else if (*mime).mm_type == MAILMIME_MESSAGE as libc::c_int { } else if (*mime).mm_type == MAILMIME_MESSAGE as libc::c_int {
@@ -1111,9 +1111,9 @@ Sent with my Delta Chat Messenger: https://delta.chat";
}; };
unsafe { unsafe {
let msg1 = (*decrypted_mime).mm_data.mm_message.mm_msg_mime; let msg1 = (*decrypted_mime).mm_data.mm_message.mm_msg_mime;
let mut decoded_data = 0 as *const libc::c_char; let mut decoded_data = ptr::null();
let mut decoded_data_bytes = 0; let mut decoded_data_bytes = 0;
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();
assert_eq!( assert_eq!(
mailmime_transfer_decode( mailmime_transfer_decode(

6
src/dc_imex.rs
View File

@@ -991,9 +991,9 @@ unsafe fn import_self_keys(context: &Context, dir_name: *const libc::c_char) ->
if dc_split_armored_data( if dc_split_armored_data(
buf2, buf2,
&mut buf2_headerline, &mut buf2_headerline,
0 as *mut *const libc::c_char, ptr::null_mut(),
0 as *mut *const libc::c_char, ptr::null_mut(),
0 as *mut *const libc::c_char, ptr::null_mut(),
) && strcmp( ) && strcmp(
buf2_headerline, buf2_headerline,
b"-----BEGIN PGP PUBLIC KEY BLOCK-----\x00" as *const u8 as *const libc::c_char, b"-----BEGIN PGP PUBLIC KEY BLOCK-----\x00" as *const u8 as *const libc::c_char,

121
src/dc_mimefactory.rs
View File

@@ -187,7 +187,7 @@ pub unsafe fn dc_mimefactory_load_msg(
clist_insert_after( clist_insert_after(
factory.recipients_names, factory.recipients_names,
(*factory.recipients_names).last, (*factory.recipients_names).last,
0 as *mut libc::c_void, ptr::null_mut(),
); );
clist_insert_after( clist_insert_after(
factory.recipients_addr, factory.recipients_addr,
@@ -318,7 +318,7 @@ pub unsafe fn dc_mimefactory_load_mdn<'a>(
(if !contact.get_authname().is_empty() { (if !contact.get_authname().is_empty() {
contact.get_authname().strdup() contact.get_authname().strdup()
} else { } else {
0 as *mut libc::c_char ptr::null_mut()
}) as *mut libc::c_void, }) as *mut libc::c_void,
); );
clist_insert_after( clist_insert_after(
@@ -339,10 +339,10 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
let subject: *mut mailimf_subject; let subject: *mut mailimf_subject;
let mut ok_to_continue = true; let mut ok_to_continue = true;
let imf_fields: *mut mailimf_fields; let imf_fields: *mut mailimf_fields;
let mut message: *mut mailmime = 0 as *mut mailmime; let mut message: *mut mailmime = ptr::null_mut();
let mut message_text: *mut libc::c_char = 0 as *mut libc::c_char; let mut message_text: *mut libc::c_char = ptr::null_mut();
let mut message_text2: *mut libc::c_char = 0 as *mut libc::c_char; let mut message_text2: *mut libc::c_char = ptr::null_mut();
let mut subject_str: *mut libc::c_char = 0 as *mut libc::c_char; let mut subject_str: *mut libc::c_char = ptr::null_mut();
let mut afwd_email: libc::c_int = 0; let mut afwd_email: libc::c_int = 0;
let mut col: libc::c_int = 0; let mut col: libc::c_int = 0;
let mut success: libc::c_int = 0; let mut success: libc::c_int = 0;
@@ -355,7 +355,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
let mut grpimage = None; let mut grpimage = None;
let mut e2ee_helper = dc_e2ee_helper_t { let mut e2ee_helper = dc_e2ee_helper_t {
encryption_successfull: 0, encryption_successfull: 0,
cdata_to_free: 0 as *mut libc::c_void, cdata_to_free: ptr::null_mut(),
encrypted: 0, encrypted: 0,
signatures: Default::default(), signatures: Default::default(),
gossipped_addr: Default::default(), gossipped_addr: Default::default(),
@@ -377,12 +377,12 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
if !factory.from_displayname.is_null() { if !factory.from_displayname.is_null() {
dc_encode_header_words(factory.from_displayname) dc_encode_header_words(factory.from_displayname)
} else { } else {
0 as *mut libc::c_char ptr::null_mut()
}, },
dc_strdup(factory.from_addr), dc_strdup(factory.from_addr),
), ),
); );
let mut to: *mut mailimf_address_list = 0 as *mut mailimf_address_list; let mut to: *mut mailimf_address_list = ptr::null_mut();
if !factory.recipients_names.is_null() if !factory.recipients_names.is_null()
&& !factory.recipients_addr.is_null() && !factory.recipients_addr.is_null()
&& (*factory.recipients_addr).count > 0 && (*factory.recipients_addr).count > 0
@@ -396,12 +396,12 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
let name: *const libc::c_char = (if !iter1.is_null() { let name: *const libc::c_char = (if !iter1.is_null() {
(*iter1).data (*iter1).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *const libc::c_char; }) as *const libc::c_char;
let addr: *const libc::c_char = (if !iter2.is_null() { let addr: *const libc::c_char = (if !iter2.is_null() {
(*iter2).data (*iter2).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *const libc::c_char; }) as *const libc::c_char;
mailimf_address_list_add( mailimf_address_list_add(
to, to,
@@ -411,33 +411,33 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
if !name.is_null() { if !name.is_null() {
dc_encode_header_words(name) dc_encode_header_words(name)
} else { } else {
0 as *mut libc::c_char ptr::null_mut()
}, },
dc_strdup(addr), dc_strdup(addr),
), ),
0 as *mut mailimf_group, ptr::null_mut(),
), ),
); );
iter1 = if !iter1.is_null() { iter1 = if !iter1.is_null() {
(*iter1).next (*iter1).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
}; };
iter2 = if !iter2.is_null() { iter2 = if !iter2.is_null() {
(*iter2).next (*iter2).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
let mut references_list: *mut clist = 0 as *mut clist; let mut references_list: *mut clist = ptr::null_mut();
if !factory.references.is_null() && 0 != *factory.references.offset(0isize) as libc::c_int { if !factory.references.is_null() && 0 != *factory.references.offset(0isize) as libc::c_int {
references_list = dc_str_to_clist( references_list = dc_str_to_clist(
factory.references, factory.references,
b" \x00" as *const u8 as *const libc::c_char, b" \x00" as *const u8 as *const libc::c_char,
) )
} }
let mut in_reply_to_list: *mut clist = 0 as *mut clist; let mut in_reply_to_list: *mut clist = ptr::null_mut();
if !factory.in_reply_to.is_null() && 0 != *factory.in_reply_to.offset(0isize) as libc::c_int if !factory.in_reply_to.is_null() && 0 != *factory.in_reply_to.offset(0isize) as libc::c_int
{ {
in_reply_to_list = dc_str_to_clist( in_reply_to_list = dc_str_to_clist(
@@ -448,15 +448,15 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
imf_fields = mailimf_fields_new_with_data_all( imf_fields = mailimf_fields_new_with_data_all(
mailimf_get_date(factory.timestamp as i64), mailimf_get_date(factory.timestamp as i64),
from, from,
0 as *mut mailimf_mailbox, ptr::null_mut(),
0 as *mut mailimf_address_list, ptr::null_mut(),
to, to,
0 as *mut mailimf_address_list, ptr::null_mut(),
0 as *mut mailimf_address_list, ptr::null_mut(),
dc_strdup(factory.rfc724_mid), dc_strdup(factory.rfc724_mid),
in_reply_to_list, in_reply_to_list,
references_list, references_list,
0 as *mut libc::c_char, ptr::null_mut(),
); );
let os_name = &factory.context.os_name; let os_name = &factory.context.os_name;
@@ -503,8 +503,8 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
/* Render a normal message /* Render a normal message
*********************************************************************/ *********************************************************************/
let chat = factory.chat.as_ref().unwrap(); let chat = factory.chat.as_ref().unwrap();
let mut meta_part: *mut mailmime = 0 as *mut mailmime; let mut meta_part: *mut mailmime = ptr::null_mut();
let mut placeholdertext: *mut libc::c_char = 0 as *mut libc::c_char; let mut placeholdertext: *mut libc::c_char = ptr::null_mut();
if chat.typ == Chattype::VerifiedGroup { if chat.typ == Chattype::VerifiedGroup {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
@@ -736,7 +736,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
meta.type_0 = Viewtype::Image; meta.type_0 = Viewtype::Image;
meta.param.set(Param::File, grpimage); meta.param.set(Param::File, grpimage);
let mut filename_as_sent = 0 as *mut libc::c_char; let mut filename_as_sent = ptr::null_mut();
meta_part = build_body_file( meta_part = build_body_file(
&meta, &meta,
b"group-image\x00" as *const u8 as *const libc::c_char, b"group-image\x00" as *const u8 as *const libc::c_char,
@@ -785,7 +785,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
} }
} }
afwd_email = factory.msg.param.exists(Param::Forwarded) as libc::c_int; afwd_email = factory.msg.param.exists(Param::Forwarded) as libc::c_int;
let mut fwdhint = 0 as *mut libc::c_char; let mut fwdhint = ptr::null_mut();
if 0 != afwd_email { if 0 != afwd_email {
fwdhint = dc_strdup( fwdhint = dc_strdup(
b"---------- Forwarded message ----------\r\nFrom: Delta Chat\r\n\r\n\x00" b"---------- Forwarded message ----------\r\nFrom: Delta Chat\r\n\r\n\x00"
@@ -850,11 +850,8 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
free(error as *mut libc::c_void); free(error as *mut libc::c_void);
ok_to_continue = false; ok_to_continue = false;
} else { } else {
let file_part: *mut mailmime = build_body_file( let file_part: *mut mailmime =
&factory.msg, build_body_file(&factory.msg, ptr::null(), ptr::null_mut());
0 as *const libc::c_char,
0 as *mut *mut libc::c_char,
);
if !file_part.is_null() { if !file_part.is_null() {
mailmime_smart_add_part(message, file_part); mailmime_smart_add_part(message, file_part);
parts += 1 parts += 1
@@ -1011,28 +1008,28 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
imf_fields, imf_fields,
mailimf_field_new( mailimf_field_new(
MAILIMF_FIELD_SUBJECT as libc::c_int, MAILIMF_FIELD_SUBJECT as libc::c_int,
0 as *mut mailimf_return, ptr::null_mut(),
0 as *mut mailimf_orig_date, ptr::null_mut(),
0 as *mut mailimf_from, ptr::null_mut(),
0 as *mut mailimf_sender, ptr::null_mut(),
0 as *mut mailimf_to, ptr::null_mut(),
0 as *mut mailimf_cc, ptr::null_mut(),
0 as *mut mailimf_bcc, ptr::null_mut(),
0 as *mut mailimf_message_id, ptr::null_mut(),
0 as *mut mailimf_orig_date, ptr::null_mut(),
0 as *mut mailimf_from, ptr::null_mut(),
0 as *mut mailimf_sender, ptr::null_mut(),
0 as *mut mailimf_reply_to, ptr::null_mut(),
0 as *mut mailimf_to, ptr::null_mut(),
0 as *mut mailimf_cc, ptr::null_mut(),
0 as *mut mailimf_bcc, ptr::null_mut(),
0 as *mut mailimf_message_id, ptr::null_mut(),
0 as *mut mailimf_in_reply_to, ptr::null_mut(),
0 as *mut mailimf_references, ptr::null_mut(),
subject, subject,
0 as *mut mailimf_comments, ptr::null_mut(),
0 as *mut mailimf_keywords, ptr::null_mut(),
0 as *mut mailimf_optional_field, ptr::null_mut(),
), ),
); );
if force_plaintext != 2 { if force_plaintext != 2 {
@@ -1151,7 +1148,7 @@ unsafe fn build_body_file(
) -> *mut mailmime { ) -> *mut mailmime {
let needs_ext: bool; let needs_ext: bool;
let mime_fields: *mut mailmime_fields; let mime_fields: *mut mailmime_fields;
let mut mime_sub: *mut mailmime = 0 as *mut mailmime; let mut mime_sub: *mut mailmime = ptr::null_mut();
let content: *mut mailmime_content; let content: *mut mailmime_content;
let path_filename = msg.param.get(Param::File); let path_filename = msg.param.get(Param::File);
@@ -1161,8 +1158,8 @@ unsafe fn build_body_file(
.map(|s| s.strdup()) .map(|s| s.strdup())
.unwrap_or_else(|| std::ptr::null_mut()); .unwrap_or_else(|| std::ptr::null_mut());
let mut filename_to_send = 0 as *mut libc::c_char; let mut filename_to_send = ptr::null_mut();
let mut filename_encoded = 0 as *mut libc::c_char; let mut filename_encoded = ptr::null_mut();
if let Some(ref path_filename) = path_filename { if let Some(ref path_filename) = path_filename {
let suffix = dc_get_filesuffix_lc(path_filename); let suffix = dc_get_filesuffix_lc(path_filename);
@@ -1232,7 +1229,7 @@ unsafe fn build_body_file(
mime_fields = mailmime_fields_new_filename( mime_fields = mailmime_fields_new_filename(
MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int, MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
if needs_ext { if needs_ext {
0 as *mut libc::c_char ptr::null_mut()
} else { } else {
dc_strdup(filename_to_send) dc_strdup(filename_to_send)
}, },
@@ -1244,7 +1241,7 @@ unsafe fn build_body_file(
let field: *mut mailmime_field = (if !cur1.is_null() { let field: *mut mailmime_field = (if !cur1.is_null() {
(*cur1).data (*cur1).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime_field; }) as *mut mailmime_field;
if !field.is_null() if !field.is_null()
&& (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int && (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int
@@ -1256,10 +1253,10 @@ unsafe fn build_body_file(
let parm: *mut mailmime_disposition_parm = let parm: *mut mailmime_disposition_parm =
mailmime_disposition_parm_new( mailmime_disposition_parm_new(
MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int, MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int,
0 as *mut libc::c_char, ptr::null_mut(),
0 as *mut libc::c_char, ptr::null_mut(),
0 as *mut libc::c_char, ptr::null_mut(),
0 as *mut libc::c_char, ptr::null_mut(),
0 as size_t, 0 as size_t,
mailmime_parameter_new( mailmime_parameter_new(
strdup( strdup(
@@ -1281,7 +1278,7 @@ unsafe fn build_body_file(
cur1 = if !cur1.is_null() { cur1 = if !cur1.is_null() {
(*cur1).next (*cur1).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }

165
src/dc_mimeparser.rs
View File

@@ -1,5 +1,6 @@
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::ffi::{CStr, CString}; use std::ffi::{CStr, CString};
use std::ptr;
use charset::Charset; use charset::Charset;
use mmime::mailimf::*; use mmime::mailimf::*;
@@ -23,7 +24,6 @@ use crate::param::*;
use crate::stock::StockMessage; use crate::stock::StockMessage;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
use std::ptr;
/* Parse MIME body; this is the text part of an IMF, see https://tools.ietf.org/html/rfc5322 /* Parse MIME body; this is the text part of an IMF, see https://tools.ietf.org/html/rfc5322
dc_mimeparser_t has no deep dependencies to Context or to the database dc_mimeparser_t has no deep dependencies to Context or to the database
@@ -92,19 +92,19 @@ unsafe fn dc_mimeparser_empty(mimeparser: &mut dc_mimeparser_t) {
dc_mimepart_unref(part); dc_mimepart_unref(part);
} }
assert!(mimeparser.parts.is_empty()); assert!(mimeparser.parts.is_empty());
mimeparser.header_root = 0 as *mut mailimf_fields; mimeparser.header_root = ptr::null_mut();
mimeparser.header.clear(); mimeparser.header.clear();
if !mimeparser.header_protected.is_null() { if !mimeparser.header_protected.is_null() {
mailimf_fields_free(mimeparser.header_protected); mailimf_fields_free(mimeparser.header_protected);
mimeparser.header_protected = 0 as *mut mailimf_fields mimeparser.header_protected = ptr::null_mut()
} }
mimeparser.is_send_by_messenger = false; mimeparser.is_send_by_messenger = false;
mimeparser.is_system_message = 0i32; mimeparser.is_system_message = 0i32;
free(mimeparser.subject as *mut libc::c_void); free(mimeparser.subject as *mut libc::c_void);
mimeparser.subject = 0 as *mut libc::c_char; mimeparser.subject = ptr::null_mut();
if !mimeparser.mimeroot.is_null() { if !mimeparser.mimeroot.is_null() {
mailmime_free(mimeparser.mimeroot); mailmime_free(mimeparser.mimeroot);
mimeparser.mimeroot = 0 as *mut mailmime mimeparser.mimeroot = ptr::null_mut()
} }
mimeparser.is_forwarded = 0i32; mimeparser.is_forwarded = 0i32;
mimeparser.reports.clear(); mimeparser.reports.clear();
@@ -118,7 +118,7 @@ unsafe fn dc_mimeparser_empty(mimeparser: &mut dc_mimeparser_t) {
unsafe fn dc_mimepart_unref(mut mimepart: dc_mimepart_t) { unsafe fn dc_mimepart_unref(mut mimepart: dc_mimepart_t) {
mimepart.msg = None; mimepart.msg = None;
free(mimepart.msg_raw as *mut libc::c_void); free(mimepart.msg_raw as *mut libc::c_void);
mimepart.msg_raw = 0 as *mut libc::c_char; mimepart.msg_raw = ptr::null_mut();
} }
const DC_MIMETYPE_AC_SETUP_FILE: i32 = 111; const DC_MIMETYPE_AC_SETUP_FILE: i32 = 111;
@@ -310,7 +310,7 @@ pub unsafe fn dc_mimeparser_parse<'a>(context: &'a Context, body: &[u8]) -> dc_m
"Chat-Disposition-Notification-To", "Chat-Disposition-Notification-To",
); );
if !dn_field.is_null() && dc_mimeparser_get_last_nonmeta(&mut mimeparser).is_some() { if !dn_field.is_null() && dc_mimeparser_get_last_nonmeta(&mut mimeparser).is_some() {
let mut mb_list: *mut mailimf_mailbox_list = 0 as *mut mailimf_mailbox_list; let mut mb_list: *mut mailimf_mailbox_list = ptr::null_mut();
let mut index_0: size_t = 0i32 as size_t; let mut index_0: size_t = 0i32 as size_t;
if mailimf_mailbox_list_parse( if mailimf_mailbox_list_parse(
(*dn_field).fld_value, (*dn_field).fld_value,
@@ -391,14 +391,14 @@ pub fn dc_mimeparser_get_last_nonmeta<'a>(
/*the result must be freed*/ /*the result must be freed*/
pub unsafe fn mailimf_find_first_addr(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() { if mb_list.is_null() {
return 0 as *mut libc::c_char; return ptr::null_mut();
} }
let mut cur: *mut clistiter = (*(*mb_list).mb_list).first; let mut cur: *mut clistiter = (*(*mb_list).mb_list).first;
while !cur.is_null() { while !cur.is_null() {
let mb: *mut mailimf_mailbox = (if !cur.is_null() { let mb: *mut mailimf_mailbox = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_mailbox; }) as *mut mailimf_mailbox;
if !mb.is_null() && !(*mb).mb_addr_spec.is_null() { if !mb.is_null() && !(*mb).mb_addr_spec.is_null() {
return addr_normalize(as_str((*mb).mb_addr_spec)).strdup(); return addr_normalize(as_str((*mb).mb_addr_spec)).strdup();
@@ -406,11 +406,11 @@ pub unsafe fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> *
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
0 as *mut libc::c_char ptr::null_mut()
} }
/* the following functions can be used only after a call to dc_mimeparser_parse() */ /* the following functions can be used only after a call to dc_mimeparser_parse() */
@@ -439,7 +439,7 @@ pub unsafe fn dc_mimeparser_lookup_optional_field(
return (*field).fld_data.fld_optional_field; return (*field).fld_data.fld_optional_field;
} }
0 as *mut mailimf_optional_field ptr::null_mut()
} }
unsafe fn dc_mimeparser_parse_mime_recursive( unsafe fn dc_mimeparser_parse_mime_recursive(
@@ -507,20 +507,17 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
// TODO match on enums /rtn // TODO match on enums /rtn
1 => any_part_added = dc_mimeparser_add_single_part_if_known(mimeparser, mime), 1 => any_part_added = dc_mimeparser_add_single_part_if_known(mimeparser, mime),
2 => { 2 => {
match mailmime_get_mime_type(mime, ptr::null_mut(), 0 as *mut *mut libc::c_char) { match mailmime_get_mime_type(mime, ptr::null_mut(), ptr::null_mut()) {
10 => { 10 => {
cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first; cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
while !cur.is_null() { while !cur.is_null() {
let childmime: *mut mailmime = (if !cur.is_null() { let childmime: *mut mailmime = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime; }) as *mut mailmime;
if mailmime_get_mime_type( if mailmime_get_mime_type(childmime, ptr::null_mut(), ptr::null_mut())
childmime, == 30i32
ptr::null_mut(),
0 as *mut *mut libc::c_char,
) == 30i32
{ {
any_part_added = any_part_added =
dc_mimeparser_parse_mime_recursive(mimeparser, childmime); dc_mimeparser_parse_mime_recursive(mimeparser, childmime);
@@ -529,7 +526,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -539,14 +536,11 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
let childmime_0: *mut mailmime = (if !cur.is_null() { let childmime_0: *mut mailmime = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) })
as *mut mailmime; as *mut mailmime;
if mailmime_get_mime_type( if mailmime_get_mime_type(childmime_0, ptr::null_mut(), ptr::null_mut())
childmime_0, == 60i32
ptr::null_mut(),
0 as *mut *mut libc::c_char,
) == 60i32
{ {
any_part_added = any_part_added =
dc_mimeparser_parse_mime_recursive(mimeparser, childmime_0); dc_mimeparser_parse_mime_recursive(mimeparser, childmime_0);
@@ -555,7 +549,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -568,7 +562,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
(if !cur.is_null() { (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime, }) as *mut mailmime,
) { ) {
any_part_added = 1i32; any_part_added = 1i32;
@@ -578,7 +572,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -592,7 +586,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
(if !cur.is_null() { (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime, }) as *mut mailmime,
) )
} }
@@ -620,7 +614,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
(if !cur.is_null() { (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime, }) as *mut mailmime,
) )
} }
@@ -645,15 +639,15 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
(if !(*(*mime).mm_data.mm_multipart.mm_mp_list).first.is_null() { (if !(*(*mime).mm_data.mm_multipart.mm_mp_list).first.is_null() {
(*(*(*mime).mm_data.mm_multipart.mm_mp_list).first).data (*(*(*mime).mm_data.mm_multipart.mm_mp_list).first).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime, }) as *mut mailmime,
) )
} }
} }
} }
_ => { _ => {
let mut skip_part: *mut mailmime = 0 as *mut mailmime; let mut skip_part: *mut mailmime = ptr::null_mut();
let mut html_part: *mut mailmime = 0 as *mut mailmime; let mut html_part: *mut mailmime = ptr::null_mut();
let mut plain_cnt: libc::c_int = 0i32; let mut plain_cnt: libc::c_int = 0i32;
let mut html_cnt: libc::c_int = 0i32; let mut html_cnt: libc::c_int = 0i32;
cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first; cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
@@ -661,20 +655,17 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
let childmime_1: *mut mailmime = (if !cur.is_null() { let childmime_1: *mut mailmime = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) })
as *mut mailmime; as *mut mailmime;
if mailmime_get_mime_type( if mailmime_get_mime_type(childmime_1, ptr::null_mut(), ptr::null_mut())
childmime_1, == 60i32
ptr::null_mut(),
0 as *mut *mut libc::c_char,
) == 60i32
{ {
plain_cnt += 1 plain_cnt += 1
} else if mailmime_get_mime_type( } else if mailmime_get_mime_type(
childmime_1, childmime_1,
ptr::null_mut(), ptr::null_mut(),
0 as *mut *mut libc::c_char, ptr::null_mut(),
) == 70i32 ) == 70i32
{ {
html_part = childmime_1; html_part = childmime_1;
@@ -683,7 +674,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
if plain_cnt == 1i32 && html_cnt == 1i32 { if plain_cnt == 1i32 && html_cnt == 1i32 {
@@ -699,7 +690,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
let childmime_2: *mut mailmime = (if !cur.is_null() { let childmime_2: *mut mailmime = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) })
as *mut mailmime; as *mut mailmime;
if childmime_2 != skip_part { if childmime_2 != skip_part {
@@ -710,7 +701,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -751,9 +742,9 @@ unsafe fn hash_header(
let field: *mut mailimf_field = (if !cur1.is_null() { let field: *mut mailimf_field = (if !cur1.is_null() {
(*cur1).data (*cur1).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_field; }) as *mut mailimf_field;
let mut key: *const libc::c_char = 0 as *const libc::c_char; let mut key: *const libc::c_char = ptr::null();
// TODO match on enums /rtn // TODO match on enums /rtn
match (*field).fld_type { match (*field).fld_type {
1 => key = b"Return-Path\x00" as *const u8 as *const libc::c_char, 1 => key = b"Return-Path\x00" as *const u8 as *const libc::c_char,
@@ -794,7 +785,7 @@ unsafe fn hash_header(
cur1 = if !cur1.is_null() { cur1 = if !cur1.is_null() {
(*cur1).next (*cur1).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -962,7 +953,7 @@ unsafe fn mailmime_is_attachment_disposition(mime: *mut mailmime) -> libc::c_int
let field: *mut mailmime_field = (if !cur.is_null() { let field: *mut mailmime_field = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime_field; }) as *mut mailmime_field;
if !field.is_null() if !field.is_null()
&& (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int && (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int
@@ -978,7 +969,7 @@ unsafe fn mailmime_is_attachment_disposition(mime: *mut mailmime) -> libc::c_int
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -996,7 +987,7 @@ pub unsafe fn mailmime_find_ct_parameter(
|| (*mime).mm_content_type.is_null() || (*mime).mm_content_type.is_null()
|| (*(*mime).mm_content_type).ct_parameters.is_null() || (*(*mime).mm_content_type).ct_parameters.is_null()
{ {
return 0 as *mut mailmime_parameter; return ptr::null_mut();
} }
let mut cur: *mut clistiter; let mut cur: *mut clistiter;
cur = (*(*(*mime).mm_content_type).ct_parameters).first; cur = (*(*(*mime).mm_content_type).ct_parameters).first;
@@ -1004,7 +995,7 @@ pub unsafe fn mailmime_find_ct_parameter(
let param: *mut mailmime_parameter = (if !cur.is_null() { let param: *mut mailmime_parameter = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime_parameter; }) as *mut mailmime_parameter;
if !param.is_null() && !(*param).pa_name.is_null() { if !param.is_null() && !(*param).pa_name.is_null() {
if strcmp((*param).pa_name, name) == 0i32 { if strcmp((*param).pa_name, name) == 0i32 {
@@ -1014,11 +1005,11 @@ pub unsafe fn mailmime_find_ct_parameter(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
0 as *mut mailmime_parameter ptr::null_mut()
} }
unsafe fn dc_mimeparser_add_single_part_if_known( unsafe fn dc_mimeparser_add_single_part_if_known(
@@ -1029,14 +1020,14 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
let old_part_count = mimeparser.parts.len(); let old_part_count = mimeparser.parts.len();
let mime_type: libc::c_int; let mime_type: libc::c_int;
let mime_data: *mut mailmime_data; let mime_data: *mut mailmime_data;
let file_suffix: *mut libc::c_char = 0 as *mut libc::c_char; let file_suffix: *mut libc::c_char = ptr::null_mut();
let mut desired_filename: *mut libc::c_char = 0 as *mut libc::c_char; let mut desired_filename: *mut libc::c_char = ptr::null_mut();
let mut msg_type = Viewtype::Unknown; let mut msg_type = Viewtype::Unknown;
let mut raw_mime: *mut libc::c_char = 0 as *mut libc::c_char; let mut raw_mime: *mut libc::c_char = ptr::null_mut();
/* mmap_string_unref()'d if set */ /* 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 */ /* 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();
let mut decoded_data_bytes = 0; let mut decoded_data_bytes = 0;
let mut simplifier: Option<Simplify> = None; let mut simplifier: Option<Simplify> = None;
if !(mime.is_null() || (*mime).mm_data.mm_single.is_null()) { if !(mime.is_null() || (*mime).mm_data.mm_single.is_null()) {
@@ -1142,7 +1133,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
let field: *mut mailmime_field = (if !cur1.is_null() { let field: *mut mailmime_field = (if !cur1.is_null() {
(*cur1).data (*cur1).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) })
as *mut mailmime_field; as *mut mailmime_field;
if !field.is_null() if !field.is_null()
@@ -1159,7 +1150,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
(if !cur2.is_null() { (if !cur2.is_null() {
(*cur2).data (*cur2).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) })
as *mut mailmime_disposition_parm; as *mut mailmime_disposition_parm;
if !dsp_param.is_null() { if !dsp_param.is_null() {
@@ -1191,7 +1182,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
cur2 = if !cur2.is_null() { cur2 = if !cur2.is_null() {
(*cur2).next (*cur2).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -1200,7 +1191,7 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
cur1 = if !cur1.is_null() { cur1 = if !cur1.is_null() {
(*cur1).next (*cur1).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -1376,7 +1367,7 @@ pub unsafe fn mailmime_transfer_decode(
let decoded_data: *const libc::c_char; let decoded_data: *const libc::c_char;
let mut decoded_data_bytes: size_t = 0i32 as size_t; let mut decoded_data_bytes: size_t = 0i32 as size_t;
/* mmap_string_unref()'d if set */ /* 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();
if mime.is_null() if mime.is_null()
|| ret_decoded_data.is_null() || ret_decoded_data.is_null()
|| ret_decoded_data_bytes.is_null() || ret_decoded_data_bytes.is_null()
@@ -1395,7 +1386,7 @@ pub unsafe fn mailmime_transfer_decode(
let field: *mut mailmime_field = (if !cur.is_null() { let field: *mut mailmime_field = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime_field; }) as *mut mailmime_field;
if !field.is_null() if !field.is_null()
&& (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int && (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int
@@ -1407,7 +1398,7 @@ pub unsafe fn mailmime_transfer_decode(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -1473,7 +1464,7 @@ pub unsafe fn dc_mimeparser_is_mailinglist_message(mimeparser: &dc_mimeparser_t)
pub unsafe fn dc_mimeparser_sender_equals_recipient(mimeparser: &dc_mimeparser_t) -> libc::c_int { pub unsafe fn dc_mimeparser_sender_equals_recipient(mimeparser: &dc_mimeparser_t) -> libc::c_int {
let mut sender_equals_recipient: libc::c_int = 0i32; let mut sender_equals_recipient: libc::c_int = 0i32;
let fld: *const mailimf_field; let fld: *const mailimf_field;
let mut fld_from: *const mailimf_from = 0 as *const mailimf_from; let mut fld_from: *const mailimf_from = ptr::null();
let mb: *mut mailimf_mailbox; let mb: *mut mailimf_mailbox;
if !mimeparser.header_root.is_null() { if !mimeparser.header_root.is_null() {
@@ -1491,7 +1482,7 @@ pub unsafe fn dc_mimeparser_sender_equals_recipient(mimeparser: &dc_mimeparser_t
mb = (if !(*(*(*fld_from).frm_mb_list).mb_list).first.is_null() { mb = (if !(*(*(*fld_from).frm_mb_list).mb_list).first.is_null() {
(*(*(*(*fld_from).frm_mb_list).mb_list).first).data (*(*(*(*fld_from).frm_mb_list).mb_list).first).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_mailbox; }) as *mut mailimf_mailbox;
if !mb.is_null() { if !mb.is_null() {
let from_addr_norm = addr_normalize(as_str((*mb).mb_addr_spec)); let from_addr_norm = addr_normalize(as_str((*mb).mb_addr_spec));
@@ -1517,11 +1508,11 @@ pub unsafe fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<
let fld: *mut mailimf_field = (if !cur1.is_null() { let fld: *mut mailimf_field = (if !cur1.is_null() {
(*cur1).data (*cur1).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_field; }) as *mut mailimf_field;
let fld_to: *mut mailimf_to; let fld_to: *mut mailimf_to;
let fld_cc: *mut mailimf_cc; let fld_cc: *mut mailimf_cc;
let mut addr_list: *mut mailimf_address_list = 0 as *mut mailimf_address_list; let mut addr_list: *mut mailimf_address_list = ptr::null_mut();
// TODO match on enums /rtn // TODO match on enums /rtn
match (*fld).fld_type { match (*fld).fld_type {
13 => { 13 => {
@@ -1545,7 +1536,7 @@ pub unsafe fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<
let adr: *mut mailimf_address = (if !cur2.is_null() { let adr: *mut mailimf_address = (if !cur2.is_null() {
(*cur2).data (*cur2).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_address; }) as *mut mailimf_address;
if !adr.is_null() { if !adr.is_null() {
if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int { if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
@@ -1564,13 +1555,13 @@ pub unsafe fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<
(if !cur3.is_null() { (if !cur3.is_null() {
(*cur3).data (*cur3).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_mailbox, }) as *mut mailimf_mailbox,
); );
cur3 = if !cur3.is_null() { cur3 = if !cur3.is_null() {
(*cur3).next (*cur3).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -1579,14 +1570,14 @@ pub unsafe fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<
cur2 = if !cur2.is_null() { cur2 = if !cur2.is_null() {
(*cur2).next (*cur2).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
cur1 = if !cur1.is_null() { cur1 = if !cur1.is_null() {
(*cur1).next (*cur1).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
@@ -1618,14 +1609,14 @@ pub unsafe fn mailimf_find_field(
wanted_fld_type: libc::c_int, wanted_fld_type: libc::c_int,
) -> *mut mailimf_field { ) -> *mut mailimf_field {
if header.is_null() || (*header).fld_list.is_null() { if header.is_null() || (*header).fld_list.is_null() {
return 0 as *mut mailimf_field; return ptr::null_mut();
} }
let mut cur1: *mut clistiter = (*(*header).fld_list).first; let mut cur1: *mut clistiter = (*(*header).fld_list).first;
while !cur1.is_null() { while !cur1.is_null() {
let field: *mut mailimf_field = (if !cur1.is_null() { let field: *mut mailimf_field = (if !cur1.is_null() {
(*cur1).data (*cur1).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_field; }) as *mut mailimf_field;
if !field.is_null() { if !field.is_null() {
if (*field).fld_type == wanted_fld_type { if (*field).fld_type == wanted_fld_type {
@@ -1635,11 +1626,11 @@ pub unsafe fn mailimf_find_field(
cur1 = if !cur1.is_null() { cur1 = if !cur1.is_null() {
(*cur1).next (*cur1).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
0 as *mut mailimf_field ptr::null_mut()
} }
pub unsafe fn dc_mimeparser_repl_msg_by_error( pub unsafe fn dc_mimeparser_repl_msg_by_error(
@@ -1661,7 +1652,7 @@ pub unsafe fn dc_mimeparser_repl_msg_by_error(
/*the result is a pointer to mime, must not be freed*/ /*the result is a pointer to mime, must not be freed*/
pub unsafe fn mailmime_find_mailimf_fields(mime: *mut mailmime) -> *mut mailimf_fields { pub unsafe fn mailmime_find_mailimf_fields(mime: *mut mailmime) -> *mut mailimf_fields {
if mime.is_null() { if mime.is_null() {
return 0 as *mut mailimf_fields; return ptr::null_mut();
} }
match (*mime).mm_type as _ { match (*mime).mm_type as _ {
@@ -1672,7 +1663,7 @@ pub unsafe fn mailmime_find_mailimf_fields(mime: *mut mailmime) -> *mut mailimf_
(if !cur.is_null() { (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime, }) as *mut mailmime,
); );
if !header.is_null() { if !header.is_null() {
@@ -1681,7 +1672,7 @@ pub unsafe fn mailmime_find_mailimf_fields(mime: *mut mailmime) -> *mut mailimf_
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -1689,7 +1680,7 @@ pub unsafe fn mailmime_find_mailimf_fields(mime: *mut mailmime) -> *mut mailimf_
_ => {} _ => {}
} }
0 as *mut mailimf_fields ptr::null_mut()
} }
pub unsafe fn mailimf_find_optional_field( pub unsafe fn mailimf_find_optional_field(
@@ -1697,14 +1688,14 @@ pub unsafe fn mailimf_find_optional_field(
wanted_fld_name: *const libc::c_char, wanted_fld_name: *const libc::c_char,
) -> *mut mailimf_optional_field { ) -> *mut mailimf_optional_field {
if header.is_null() || (*header).fld_list.is_null() { if header.is_null() || (*header).fld_list.is_null() {
return 0 as *mut mailimf_optional_field; return ptr::null_mut();
} }
let mut cur1: *mut clistiter = (*(*header).fld_list).first; let mut cur1: *mut clistiter = (*(*header).fld_list).first;
while !cur1.is_null() { while !cur1.is_null() {
let field: *mut mailimf_field = (if !cur1.is_null() { let field: *mut mailimf_field = (if !cur1.is_null() {
(*cur1).data (*cur1).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_field; }) as *mut mailimf_field;
if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int { if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
let 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;
@@ -1719,11 +1710,11 @@ pub unsafe fn mailimf_find_optional_field(
cur1 = if !cur1.is_null() { cur1 = if !cur1.is_null() {
(*cur1).next (*cur1).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
0 as *mut mailimf_optional_field ptr::null_mut()
} }
#[cfg(test)] #[cfg(test)]
@@ -1737,7 +1728,7 @@ mod tests {
unsafe { unsafe {
let txt: *const libc::c_char = let txt: *const libc::c_char =
b"FieldA: ValueA\nFieldB: ValueB\n\x00" as *const u8 as *const libc::c_char; b"FieldA: ValueA\nFieldB: ValueB\n\x00" as *const u8 as *const libc::c_char;
let mut mime: *mut mailmime = 0 as *mut mailmime; let mut mime: *mut mailmime = ptr::null_mut();
let mut dummy: size_t = 0i32 as size_t; let mut dummy: size_t = 0i32 as size_t;
let res = mailmime_parse(txt, strlen(txt), &mut dummy, &mut mime); let res = mailmime_parse(txt, strlen(txt), &mut dummy, &mut mime);

26
src/dc_receive_imf.rs
View File

@@ -696,7 +696,7 @@ unsafe fn add_parts(
])?; ])?;
free(txt_raw as *mut libc::c_void); free(txt_raw as *mut libc::c_void);
txt_raw = 0 as *mut libc::c_char; txt_raw = ptr::null_mut();
*insert_msg_id = sql::get_rowid_with_conn( *insert_msg_id = sql::get_rowid_with_conn(
context, context,
conn, conn,
@@ -797,7 +797,7 @@ unsafe fn handle_reports(
{ {
(*(*(*report_root).mm_data.mm_multipart.mm_mp_list).first).next (*(*(*report_root).mm_data.mm_multipart.mm_mp_list).first).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
.is_null() .is_null()
{ {
@@ -807,11 +807,11 @@ unsafe fn handle_reports(
{ {
(*(*(*report_root).mm_data.mm_multipart.mm_mp_list).first).next (*(*(*report_root).mm_data.mm_multipart.mm_mp_list).first).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
}) })
.data .data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailmime; }) as *mut mailmime;
if !report_data.is_null() if !report_data.is_null()
@@ -1334,7 +1334,7 @@ unsafe fn create_or_lookup_group(
} }
if !X_MrGrpImageChanged.is_null() { if !X_MrGrpImageChanged.is_null() {
let mut ok = 0; let mut ok = 0;
let mut grpimage = 0 as *mut libc::c_char; let mut grpimage = ptr::null_mut();
if strcmp( if strcmp(
X_MrGrpImageChanged, X_MrGrpImageChanged,
b"0\x00" as *const u8 as *const libc::c_char, b"0\x00" as *const u8 as *const libc::c_char,
@@ -1388,7 +1388,7 @@ unsafe fn create_or_lookup_group(
let skip = if !X_MrRemoveFromGrp.is_null() { let skip = if !X_MrRemoveFromGrp.is_null() {
X_MrRemoveFromGrp X_MrRemoveFromGrp
} else { } else {
0 as *mut libc::c_char ptr::null_mut()
}; };
sql::execute( sql::execute(
context, context,
@@ -1470,7 +1470,7 @@ unsafe fn create_or_lookup_adhoc_group(
// group matching the to-list or if we can create one // group matching the to-list or if we can create one
let mut chat_id = 0; let mut chat_id = 0;
let mut chat_id_blocked = Blocked::Not; let mut chat_id_blocked = Blocked::Not;
let mut grpname = 0 as *mut libc::c_char; let mut grpname = ptr::null_mut();
let cleanup = |grpname: *mut libc::c_char, let cleanup = |grpname: *mut libc::c_char,
ret_chat_id: *mut uint32_t, ret_chat_id: *mut uint32_t,
@@ -1908,7 +1908,7 @@ unsafe fn is_known_rfc724_mid_in_list(context: &Context, mid_list: *const clist)
(if !cur.is_null() { (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *const libc::c_char, }) as *const libc::c_char,
) { ) {
return 1; return 1;
@@ -1985,7 +1985,7 @@ unsafe fn is_msgrmsg_rfc724_mid_in_list(context: &Context, mid_list: *const clis
(if !cur.is_null() { (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *const libc::c_char, }) as *const libc::c_char,
) { ) {
return 1; return 1;
@@ -2029,7 +2029,7 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list(
let adr: *mut mailimf_address = (if !cur.is_null() { let adr: *mut mailimf_address = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_address; }) as *mut mailimf_address;
if !adr.is_null() { if !adr.is_null() {
if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int { if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
@@ -2060,7 +2060,7 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }
@@ -2080,7 +2080,7 @@ unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
let mb: *mut mailimf_mailbox = (if !cur.is_null() { let mb: *mut mailimf_mailbox = (if !cur.is_null() {
(*cur).data (*cur).data
} else { } else {
0 as *mut libc::c_void ptr::null_mut()
}) as *mut mailimf_mailbox; }) as *mut mailimf_mailbox;
if !mb.is_null() { if !mb.is_null() {
add_or_lookup_contact_by_addr( add_or_lookup_contact_by_addr(
@@ -2095,7 +2095,7 @@ unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
cur = if !cur.is_null() { cur = if !cur.is_null() {
(*cur).next (*cur).next
} else { } else {
0 as *mut clistcell ptr::null_mut()
} }
} }
} }

27
src/dc_securejoin.rs
View File

@@ -1,5 +1,6 @@
use mmime::mailimf_types::*; use mmime::mailimf_types::*;
use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC}; use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
use std::ptr;
use crate::aheader::EncryptPreference; use crate::aheader::EncryptPreference;
use crate::chat::{self, Chat}; use crate::chat::{self, Chat};
@@ -30,7 +31,7 @@ pub unsafe fn dc_get_securejoin_qr(
==== Step 1 in "Setup verified contact" protocol ==== ==== Step 1 in "Setup verified contact" protocol ====
========================================================= */ ========================================================= */
let mut fingerprint = 0 as *mut libc::c_char; let mut fingerprint = ptr::null_mut();
let mut invitenumber: *mut libc::c_char; let mut invitenumber: *mut libc::c_char;
let mut auth: *mut libc::c_char; let mut auth: *mut libc::c_char;
let mut qr: Option<String> = None; let mut qr: Option<String> = None;
@@ -244,7 +245,7 @@ pub unsafe fn dc_join_securejoin(context: &Context, qr: *const libc::c_char) ->
.invitenumber .invitenumber
.as_ref() .as_ref()
.unwrap(), .unwrap(),
0 as *const libc::c_char, ptr::null(),
"", "",
); );
} }
@@ -270,7 +271,7 @@ pub unsafe fn dc_join_securejoin(context: &Context, qr: *const libc::c_char) ->
context, context,
bob.qr_scan.as_ref().unwrap().text2.as_ref().unwrap(), bob.qr_scan.as_ref().unwrap().text2.as_ref().unwrap(),
None, None,
0 as *mut libc::c_int, ptr::null_mut(),
) as libc::c_int ) as libc::c_int
} else { } else {
ret_chat_id = contact_chat_id as libc::c_int ret_chat_id = contact_chat_id as libc::c_int
@@ -371,7 +372,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
let mut current_block: u64; let mut current_block: u64;
let step: *const libc::c_char; let step: *const libc::c_char;
let join_vg: libc::c_int; let join_vg: libc::c_int;
let mut own_fingerprint: *mut libc::c_char = 0 as *mut libc::c_char; let mut own_fingerprint: *mut libc::c_char = ptr::null_mut();
let contact_chat_id: u32; let contact_chat_id: u32;
let contact_chat_id_blocked: Blocked; let contact_chat_id_blocked: Blocked;
let mut grpid = "".to_string(); let mut grpid = "".to_string();
@@ -433,7 +434,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
b"vc-auth-required\x00" as *const u8 as *const libc::c_char b"vc-auth-required\x00" as *const u8 as *const libc::c_char
}, },
"", "",
0 as *const libc::c_char, ptr::null(),
"", "",
); );
current_block = 10256747982273457880; current_block = 10256747982273457880;
@@ -636,12 +637,8 @@ pub unsafe fn dc_handle_securejoin_handshake(
); );
if 0 != join_vg { if 0 != join_vg {
grpid = to_string(lookup_field(mimeparser, "Secure-Join-Group")); grpid = to_string(lookup_field(mimeparser, "Secure-Join-Group"));
let group_chat_id: uint32_t = chat::get_chat_id_by_grpid( let group_chat_id: uint32_t =
context, chat::get_chat_id_by_grpid(context, &grpid, None, ptr::null_mut());
&grpid,
None,
0 as *mut libc::c_int,
);
if group_chat_id == 0i32 as libc::c_uint { if group_chat_id == 0i32 as libc::c_uint {
error!(context, 0, "Chat {} not found.", &grpid); error!(context, 0, "Chat {} not found.", &grpid);
current_block = 4378276786830486580; current_block = 4378276786830486580;
@@ -660,7 +657,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
contact_chat_id, contact_chat_id,
b"vc-contact-confirm\x00" as *const u8 as *const libc::c_char, b"vc-contact-confirm\x00" as *const u8 as *const libc::c_char,
"", "",
0 as *const libc::c_char, ptr::null(),
"", "",
); );
context.call_cb( context.call_cb(
@@ -813,7 +810,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
b"vg-member-added-received\x00" as *const u8 b"vg-member-added-received\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
"", "",
0 as *const libc::c_char, ptr::null(),
"", "",
); );
} }
@@ -898,7 +895,7 @@ unsafe fn secure_connection_established(context: &Context, contact_chat_id: uint
} }
unsafe fn lookup_field(mimeparser: &dc_mimeparser_t, key: &str) -> *const libc::c_char { unsafe fn lookup_field(mimeparser: &dc_mimeparser_t, key: &str) -> *const libc::c_char {
let mut value: *const libc::c_char = 0 as *const libc::c_char; let mut value: *const libc::c_char = ptr::null();
let 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() if field.is_null()
|| (*field).fld_type != MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int || (*field).fld_type != MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int
@@ -908,7 +905,7 @@ unsafe fn lookup_field(mimeparser: &dc_mimeparser_t, key: &str) -> *const libc::
value.is_null() value.is_null()
} }
{ {
return 0 as *const libc::c_char; return ptr::null();
} }
value value

11
src/dc_strencode.rs
View File

@@ -1,4 +1,5 @@
use std::ffi::{CStr, CString}; use std::ffi::{CStr, CString};
use std::ptr;
use charset::Charset; use charset::Charset;
use mmime::mailmime_decode::*; use mmime::mailmime_decode::*;
@@ -79,7 +80,7 @@ fn hex_2_int(ch: libc::c_char) -> libc::c_char {
pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut libc::c_char { pub unsafe fn dc_encode_header_words(to_encode: *const libc::c_char) -> *mut libc::c_char {
let mut ok_to_continue = true; let mut ok_to_continue = true;
let mut ret_str: *mut libc::c_char = 0 as *mut libc::c_char; let mut ret_str: *mut libc::c_char = ptr::null_mut();
let mut cur: *const libc::c_char = to_encode; let mut cur: *const libc::c_char = to_encode;
let mmapstr: *mut MMAPString = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char); 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() { if to_encode.is_null() || mmapstr.is_null() {
@@ -270,9 +271,9 @@ unsafe fn to_be_quoted(word: *const libc::c_char, size: size_t) -> bool {
pub unsafe fn dc_decode_header_words(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() { if in_0.is_null() {
return 0 as *mut libc::c_char; return ptr::null_mut();
} }
let mut out: *mut libc::c_char = 0 as *mut libc::c_char; let mut out: *mut libc::c_char = ptr::null_mut();
let mut cur_token: size_t = 0i32 as size_t; let mut cur_token: size_t = 0i32 as size_t;
let 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, b"iso-8859-1\x00" as *const u8 as *const libc::c_char,
@@ -616,8 +617,8 @@ pub unsafe fn dc_encode_ext_header(to_encode: *const libc::c_char) -> *mut libc:
} }
pub unsafe fn dc_decode_ext_header(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 decoded: *mut libc::c_char = ptr::null_mut();
let mut charset: *mut libc::c_char = 0 as *mut libc::c_char; let mut charset: *mut libc::c_char = ptr::null_mut();
let mut p2: *const libc::c_char; let mut p2: *const libc::c_char;
if !to_decode.is_null() { if !to_decode.is_null() {
// get char set // get char set

2
src/dc_tools.rs
View File

@@ -1424,7 +1424,7 @@ mod tests {
); );
assert_ne!(str_a, str_a_copy); assert_ne!(str_a, str_a_copy);
let str_a = 0 as *const u8 as *const libc::c_char; let str_a = ptr::null();
let str_a_copy = dc_strdup_keep_null(str_a); let str_a_copy = dc_strdup_keep_null(str_a);
assert_eq!(str_a.is_null(), true); assert_eq!(str_a.is_null(), true);
assert_eq!(str_a_copy.is_null(), true); assert_eq!(str_a_copy.is_null(), true);

4
src/job.rs
View File

@@ -727,7 +727,7 @@ pub unsafe fn job_send_msg(context: &Context, msg_id: uint32_t) -> libc::c_int {
clist_insert_after( clist_insert_after(
mimefactory.recipients_names, mimefactory.recipients_names,
(*mimefactory.recipients_names).last, (*mimefactory.recipients_names).last,
0 as *mut libc::c_void, ptr::null_mut(),
); );
clist_insert_after( clist_insert_after(
mimefactory.recipients_addr, mimefactory.recipients_addr,
@@ -1020,7 +1020,7 @@ fn send_mdn(context: &Context, msg_id: uint32_t) {
fn add_smtp_job(context: &Context, action: Action, mimefactory: &dc_mimefactory_t) -> libc::c_int { fn add_smtp_job(context: &Context, action: Action, mimefactory: &dc_mimefactory_t) -> libc::c_int {
let pathNfilename: *mut libc::c_char; let pathNfilename: *mut libc::c_char;
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut recipients: *mut libc::c_char = 0 as *mut libc::c_char; let mut recipients: *mut libc::c_char = ptr::null_mut();
let mut param = Params::new(); let mut param = Params::new();
pathNfilename = unsafe { pathNfilename = unsafe {
dc_get_fine_pathNfilename( dc_get_fine_pathNfilename(

20
src/message.rs
View File

@@ -378,7 +378,7 @@ pub fn dc_msg_guess_msgtype_from_suffix(path: &Path) -> Option<(Viewtype, &str)>
} }
pub unsafe fn dc_msg_get_file(msg: &Message) -> *mut libc::c_char { pub unsafe fn dc_msg_get_file(msg: &Message) -> *mut libc::c_char {
let mut file_abs = 0 as *mut libc::c_char; let mut file_abs = ptr::null_mut();
if let Some(file_rel) = msg.param.get(Param::File) { if let Some(file_rel) = msg.param.get(Param::File) {
file_abs = dc_get_abs_path(msg.context, file_rel); file_abs = dc_get_abs_path(msg.context, file_rel);
@@ -687,7 +687,7 @@ pub unsafe fn dc_msg_get_text(msg: &Message) -> *mut libc::c_char {
#[allow(non_snake_case)] #[allow(non_snake_case)]
pub unsafe fn dc_msg_get_filename(msg: &Message) -> *mut libc::c_char { pub unsafe fn dc_msg_get_filename(msg: &Message) -> *mut libc::c_char {
let mut ret = 0 as *mut libc::c_char; let mut ret = ptr::null_mut();
if let Some(file) = msg.param.get(Param::File) { if let Some(file) = msg.param.get(Param::File) {
ret = dc_get_filename(file); ret = dc_get_filename(file);
@@ -895,14 +895,14 @@ pub fn dc_msg_is_setupmessage(msg: &Message) -> bool {
} }
pub unsafe fn dc_msg_get_setupcodebegin(msg: &Message) -> *mut libc::c_char { pub unsafe fn dc_msg_get_setupcodebegin(msg: &Message) -> *mut libc::c_char {
let mut filename: *mut libc::c_char = 0 as *mut libc::c_char; let mut filename: *mut libc::c_char = ptr::null_mut();
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 = 0i32 as size_t; let mut buf_bytes: size_t = 0i32 as size_t;
// just a pointer inside buf, MUST NOT be free()'d // just a 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_headerline: *const libc::c_char = ptr::null();
// just a pointer inside buf, MUST NOT be free()'d // just a pointer inside buf, MUST NOT be free()'d
let mut buf_setupcodebegin: *const libc::c_char = 0 as *const libc::c_char; let mut buf_setupcodebegin: *const libc::c_char = ptr::null();
let mut ret: *mut libc::c_char = 0 as *mut libc::c_char; let mut ret: *mut libc::c_char = ptr::null_mut();
if dc_msg_is_setupmessage(msg) { if dc_msg_is_setupmessage(msg) {
filename = dc_msg_get_file(msg); filename = dc_msg_get_file(msg);
if !(filename.is_null() || *filename.offset(0isize) as libc::c_int == 0i32) { if !(filename.is_null() || *filename.offset(0isize) as libc::c_int == 0i32) {
@@ -920,8 +920,8 @@ pub unsafe fn dc_msg_get_setupcodebegin(msg: &Message) -> *mut libc::c_char {
buf, buf,
&mut buf_headerline, &mut buf_headerline,
&mut buf_setupcodebegin, &mut buf_setupcodebegin,
0 as *mut *const libc::c_char, ptr::null_mut(),
0 as *mut *const libc::c_char, ptr::null_mut(),
) && strcmp( ) && strcmp(
buf_headerline, buf_headerline,
b"-----BEGIN PGP MESSAGE-----\x00" as *const u8 as *const libc::c_char, b"-----BEGIN PGP MESSAGE-----\x00" as *const u8 as *const libc::c_char,
@@ -1263,7 +1263,7 @@ pub fn dc_rfc724_mid_exists(
Ok(res) => res, Ok(res) => res,
Err(_err) => { Err(_err) => {
if !ret_server_folder.is_null() { if !ret_server_folder.is_null() {
unsafe { *ret_server_folder = 0 as *mut libc::c_char }; unsafe { *ret_server_folder = ptr::null_mut() };
} }
if !ret_server_uid.is_null() { if !ret_server_uid.is_null() {
unsafe { *ret_server_uid = 0 }; unsafe { *ret_server_uid = 0 };

2
src/pgp.rs
View File

@@ -33,7 +33,7 @@ pub unsafe fn dc_split_armored_data(
let mut headerline: *mut libc::c_char = ptr::null_mut(); let mut headerline: *mut libc::c_char = ptr::null_mut();
let mut base64: *mut libc::c_char = ptr::null_mut(); let mut base64: *mut libc::c_char = ptr::null_mut();
if !ret_headerline.is_null() { if !ret_headerline.is_null() {
*ret_headerline = 0 as *const libc::c_char *ret_headerline = ptr::null()
} }
if !ret_setupcodebegin.is_null() { if !ret_setupcodebegin.is_null() {
*ret_setupcodebegin = ptr::null_mut(); *ret_setupcodebegin = ptr::null_mut();

41
tests/stress.rs
View File

@@ -2,6 +2,7 @@
use std::collections::HashSet; use std::collections::HashSet;
use std::ffi::CString; use std::ffi::CString;
use std::ptr;
use tempfile::{tempdir, TempDir}; use tempfile::{tempdir, TempDir};
@@ -68,7 +69,7 @@ unsafe fn stress_functions(context: &Context) {
assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",)); assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada",), 7); assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada",), 7);
let mut buf: *mut libc::c_void = 0 as *mut libc::c_void; let mut buf: *mut libc::c_void = ptr::null_mut();
let mut buf_bytes: size_t = 0; let mut buf_bytes: size_t = 0;
assert_eq!( assert_eq!(
@@ -161,10 +162,10 @@ unsafe fn stress_functions(context: &Context) {
assert!(res.contains(" configured_server_flags ")); assert!(res.contains(" configured_server_flags "));
let mut buf_0: *mut libc::c_char; let mut buf_0: *mut libc::c_char;
let mut headerline: *const libc::c_char = 0 as *const libc::c_char; let mut headerline: *const libc::c_char = ptr::null();
let mut setupcodebegin: *const libc::c_char = 0 as *const libc::c_char; let mut setupcodebegin: *const libc::c_char = ptr::null();
let mut preferencrypt: *const libc::c_char = 0 as *const libc::c_char; let mut preferencrypt: *const libc::c_char = ptr::null();
let mut base64: *const libc::c_char = 0 as *const libc::c_char; let mut base64: *const libc::c_char = ptr::null();
buf_0 = strdup( buf_0 = strdup(
b"-----BEGIN PGP MESSAGE-----\nNoVal:\n\ndata\n-----END PGP MESSAGE-----\x00" as *const u8 b"-----BEGIN PGP MESSAGE-----\nNoVal:\n\ndata\n-----END PGP MESSAGE-----\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -173,7 +174,7 @@ unsafe fn stress_functions(context: &Context) {
buf_0, buf_0,
&mut headerline, &mut headerline,
&mut setupcodebegin, &mut setupcodebegin,
0 as *mut *const libc::c_char, ptr::null_mut(),
&mut base64, &mut base64,
); );
assert!(ok); assert!(ok);
@@ -198,7 +199,7 @@ unsafe fn stress_functions(context: &Context) {
buf_0, buf_0,
&mut headerline, &mut headerline,
&mut setupcodebegin, &mut setupcodebegin,
0 as *mut *const libc::c_char, ptr::null_mut(),
&mut base64, &mut base64,
); );
@@ -225,7 +226,7 @@ unsafe fn stress_functions(context: &Context) {
buf_0, buf_0,
&mut headerline, &mut headerline,
&mut setupcodebegin, &mut setupcodebegin,
0 as *mut *const libc::c_char, ptr::null_mut(),
&mut base64, &mut base64,
); );
@@ -250,7 +251,7 @@ unsafe fn stress_functions(context: &Context) {
buf_0, buf_0,
&mut headerline, &mut headerline,
&mut setupcodebegin, &mut setupcodebegin,
0 as *mut *const libc::c_char, ptr::null_mut(),
&mut base64, &mut base64,
); );
@@ -263,7 +264,7 @@ unsafe fn stress_functions(context: &Context) {
buf_0, buf_0,
&mut headerline, &mut headerline,
&mut setupcodebegin, &mut setupcodebegin,
0 as *mut *const libc::c_char, ptr::null_mut(),
&mut base64, &mut base64,
); );
assert!(ok); assert!(ok);
@@ -296,7 +297,7 @@ unsafe fn stress_functions(context: &Context) {
let ok = dc_split_armored_data( let ok = dc_split_armored_data(
buf_0, buf_0,
&mut headerline, &mut headerline,
0 as *mut *const libc::c_char, ptr::null_mut(),
&mut preferencrypt, &mut preferencrypt,
&mut base64, &mut base64,
); );
@@ -352,16 +353,16 @@ unsafe fn stress_functions(context: &Context) {
); );
free(norm as *mut libc::c_void); free(norm as *mut libc::c_void);
let mut buf_1: *mut libc::c_char; let mut buf_1: *mut libc::c_char;
let mut headerline_0: *const libc::c_char = 0 as *const libc::c_char; let mut headerline_0: *const libc::c_char = ptr::null();
let mut setupcodebegin_0: *const libc::c_char = 0 as *const libc::c_char; let mut setupcodebegin_0: *const libc::c_char = ptr::null();
let mut preferencrypt_0: *const libc::c_char = 0 as *const libc::c_char; let mut preferencrypt_0: *const libc::c_char = ptr::null();
buf_1 = strdup(S_EM_SETUPFILE); buf_1 = strdup(S_EM_SETUPFILE);
assert!(dc_split_armored_data( assert!(dc_split_armored_data(
buf_1, buf_1,
&mut headerline_0, &mut headerline_0,
&mut setupcodebegin_0, &mut setupcodebegin_0,
&mut preferencrypt_0, &mut preferencrypt_0,
0 as *mut *const libc::c_char, ptr::null_mut(),
)); ));
assert!(!headerline_0.is_null()); assert!(!headerline_0.is_null());
assert_eq!( assert_eq!(
@@ -387,7 +388,7 @@ unsafe fn stress_functions(context: &Context) {
&mut headerline_0, &mut headerline_0,
&mut setupcodebegin_0, &mut setupcodebegin_0,
&mut preferencrypt_0, &mut preferencrypt_0,
0 as *mut *const libc::c_char, ptr::null_mut(),
)); ));
assert!(!headerline_0.is_null()); assert!(!headerline_0.is_null());
assert_eq!( assert_eq!(
@@ -415,16 +416,16 @@ unsafe fn stress_functions(context: &Context) {
// let setupcode_c = CString::yolo(setupcode.clone()); // let setupcode_c = CString::yolo(setupcode.clone());
// let setupfile = dc_render_setup_file(context, &setupcode).unwrap(); // let setupfile = dc_render_setup_file(context, &setupcode).unwrap();
// let setupfile_c = CString::yolo(setupfile); // let setupfile_c = CString::yolo(setupfile);
// let mut headerline_2: *const libc::c_char = 0 as *const libc::c_char; // let mut headerline_2: *const libc::c_char = ptr::null();
// let payload = dc_decrypt_setup_file(context, setupcode_c.as_ptr(), setupfile_c.as_ptr()); // let payload = dc_decrypt_setup_file(context, setupcode_c.as_ptr(), setupfile_c.as_ptr());
// assert!(payload.is_null()); // assert!(payload.is_null());
// assert!(!dc_split_armored_data( // assert!(!dc_split_armored_data(
// payload, // payload,
// &mut headerline_2, // &mut headerline_2,
// 0 as *mut *const libc::c_char, // ptr::null_mut(),
// 0 as *mut *const libc::c_char, // ptr::null_mut(),
// 0 as *mut *const libc::c_char, // ptr::null_mut(),
// )); // ));
// assert!(!headerline_2.is_null()); // assert!(!headerline_2.is_null());
// assert_eq!( // assert_eq!(