Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-04-21 15:36:30 +03:00
Code Issues Packages Projects Releases Wiki Activity

better looping on some clists

Browse Source
This commit is contained in:
holger krekel
2019-09-21 19:00:34 +02:00
parent d3dfe02ef1
commit cace6fee85
2 changed files with 55 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/dc_mimefactory.rs
View File

@@ -2,7 +2,7 @@ use std::path::Path;
use std::ptr; use std::ptr;
use chrono::TimeZone; use chrono::TimeZone;
use libc::{free, strcmp, strlen}; use libc::{free, strcmp};
use mmime::clist::*; use mmime::clist::*;
use mmime::mailimf_types::*; use mmime::mailimf_types::*;
use mmime::mailimf_types_helper::*; use mmime::mailimf_types_helper::*;
@@ -357,22 +357,12 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut MimeFactory
&& !factory.recipients_addr.is_null() && !factory.recipients_addr.is_null()
&& (*factory.recipients_addr).count > 0 && (*factory.recipients_addr).count > 0
{ {
let mut iter1: *mut clistiter; let name_iter = (*factory.recipients_names).into_iter();
let mut iter2: *mut clistiter; let addr_iter = (*factory.recipients_addr).into_iter();
to = mailimf_address_list_new_empty(); to = mailimf_address_list_new_empty();
iter1 = (*factory.recipients_names).first; for (name, addr) in name_iter.zip(addr_iter) {
iter2 = (*factory.recipients_addr).first; let name = name as *const libc::c_char;
while !iter1.is_null() && !iter2.is_null() { let addr = addr as *const libc::c_char;
let name: *const libc::c_char = (if !iter1.is_null() {
(*iter1).data
} else {
ptr::null_mut()
}) as *const libc::c_char;
let addr: *const libc::c_char = (if !iter2.is_null() {
(*iter2).data
} else {
ptr::null_mut()
}) as *const libc::c_char;
mailimf_address_list_add( mailimf_address_list_add(
to, to,
mailimf_address_new( mailimf_address_new(
@@ -388,16 +378,6 @@ pub unsafe fn dc_mimefactory_render(context: &Context, factory: &mut MimeFactory
ptr::null_mut(), ptr::null_mut(),
), ),
); );
iter1 = if !iter1.is_null() {
(*iter1).next
} else {
ptr::null_mut()
};
iter2 = if !iter2.is_null() {
(*iter2).next
} else {
ptr::null_mut()
}
} }
} }
let mut references_list: *mut clist = ptr::null_mut(); let mut references_list: *mut clist = ptr::null_mut();
@@ -1023,22 +1003,14 @@ unsafe fn build_body_file(
MAILMIME_MECHANISM_BASE64 as libc::c_int, MAILMIME_MECHANISM_BASE64 as libc::c_int,
); );
if needs_ext { if needs_ext {
let mut cur1: *mut clistiter = (*(*mime_fields).fld_list).first; for cur_data in (*(*mime_fields).fld_list).into_iter() {
while !cur1.is_null() { let field: *mut mailmime_field = cur_data as *mut _;
let field: *mut mailmime_field = (if !cur1.is_null() { if (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int
(*cur1).data
} else {
ptr::null_mut()
}) as *mut mailmime_field;
if !field.is_null()
&& (*field).fld_type == MAILMIME_FIELD_DISPOSITION as libc::c_int
&& !(*field).fld_data.fld_disposition.is_null() && !(*field).fld_data.fld_disposition.is_null()
{ {
let file_disposition: *mut mailmime_disposition = let file_disposition = (*field).fld_data.fld_disposition;
(*field).fld_data.fld_disposition;
if !file_disposition.is_null() { if !file_disposition.is_null() {
let parm: *mut mailmime_disposition_parm = let 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,
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
@@ -1046,9 +1018,7 @@ unsafe fn build_body_file(
ptr::null_mut(), ptr::null_mut(),
0 as libc::size_t, 0 as libc::size_t,
mailmime_parameter_new( mailmime_parameter_new(
strdup( strdup(b"filename*\x00" as *const u8 as *const libc::c_char),
b"filename*\x00" as *const u8 as *const libc::c_char,
),
dc_encode_ext_header(&filename_to_send).strdup(), dc_encode_ext_header(&filename_to_send).strdup(),
), ),
); );
@@ -1061,12 +1031,6 @@ unsafe fn build_body_file(
} }
} }
break; break;
} else {
cur1 = if !cur1.is_null() {
(*cur1).next
} else {
ptr::null_mut()
}
} }
} }
} }

147
src/e2ee.rs
View File

@@ -97,10 +97,8 @@ impl E2eeHelper {
/*only for random-seed*/ /*only for random-seed*/
if prefer_encrypt == EncryptPreference::Mutual || e2ee_guaranteed { if prefer_encrypt == EncryptPreference::Mutual || e2ee_guaranteed {
do_encrypt = 1i32; do_encrypt = 1i32;
let mut iter1: *mut clistiter; for cur_data in (*recipients_addr).into_iter() {
iter1 = (*recipients_addr).first; let recipient_addr = to_string(cur_data as *const libc::c_char);
while !iter1.is_null() {
let recipient_addr = to_string((*iter1).data as *const libc::c_char);
if recipient_addr != addr { if recipient_addr != addr {
let peerstate = let peerstate =
Peerstate::from_addr(context, &context.sql, &recipient_addr); Peerstate::from_addr(context, &context.sql, &recipient_addr);
@@ -130,11 +128,6 @@ impl E2eeHelper {
break; break;
} }
} }
iter1 = if !iter1.is_null() {
(*iter1).next
} else {
ptr::null_mut()
}
} }
} }
let sign_key = if 0 != do_encrypt { let sign_key = if 0 != do_encrypt {
@@ -197,63 +190,39 @@ impl E2eeHelper {
} }
} }
/* memoryhole headers */ /* memoryhole headers */
// XXX we can't use clist's into_iter()
// because the loop body also removes items
let mut cur: *mut clistiter = let mut cur: *mut clistiter =
(*(*imffields_unprotected).fld_list).first; (*(*imffields_unprotected).fld_list).first;
while !cur.is_null() { while !cur.is_null() {
let mut move_to_encrypted: libc::c_int = 0i32; let field: *mut mailimf_field = (*cur).data as *mut mailimf_field;
let field: *mut mailimf_field = (if !cur.is_null() { let mut move_to_encrypted = false;
(*cur).data
} else {
ptr::null_mut()
})
as *mut mailimf_field;
if !field.is_null() { if !field.is_null() {
if (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int { if (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
move_to_encrypted = 1i32 move_to_encrypted = true;
} else if (*field).fld_type } else if (*field).fld_type
== MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int
{ {
let opt_field: *mut mailimf_optional_field = let opt_field = (*field).fld_data.fld_optional_field;
(*field).fld_data.fld_optional_field;
if !opt_field.is_null() && !(*opt_field).fld_name.is_null() if !opt_field.is_null() && !(*opt_field).fld_name.is_null()
{ {
if strncmp( let fld_name = to_string_lossy((*opt_field).fld_name);
(*opt_field).fld_name, if fld_name.starts_with("Secure-Join")
b"Secure-Join\x00" as *const u8 || fld_name.starts_with("Chat-")
as *const libc::c_char,
11,
) == 0
|| strncmp(
(*opt_field).fld_name,
b"Chat-\x00" as *const u8
as *const libc::c_char,
5,
) == 0
&& strcmp(
(*opt_field).fld_name,
b"Chat-Version\x00" as *const u8
as *const libc::c_char,
) != 0
{ {
move_to_encrypted = 1 move_to_encrypted = true;
} }
} }
} }
} }
if 0 != move_to_encrypted { if move_to_encrypted {
mailimf_fields_add(imffields_encrypted, field); mailimf_fields_add(imffields_encrypted, field);
cur = clist_delete((*imffields_unprotected).fld_list, cur) cur = clist_delete((*imffields_unprotected).fld_list, cur);
} else { } else {
cur = if !cur.is_null() { cur = (*cur).next;
(*cur).next
} else {
ptr::null_mut()
} }
} }
} let subject: *mut mailimf_subject = mailimf_subject_new("...".strdup());
let subject: *mut mailimf_subject = mailimf_subject_new(dc_strdup(
b"...\x00" as *const u8 as *const libc::c_char,
));
mailimf_fields_add( mailimf_fields_add(
imffields_unprotected, imffields_unprotected,
mailimf_field_new( mailimf_field_new(
@@ -645,19 +614,13 @@ unsafe fn update_gossip_peerstates(
imffields: *mut mailimf_fields, imffields: *mut mailimf_fields,
gossip_headers: *const mailimf_fields, gossip_headers: *const mailimf_fields,
) -> HashSet<String> { ) -> HashSet<String> {
let mut cur1: *mut clistiter;
let mut recipients: Option<HashSet<String>> = None; let mut recipients: Option<HashSet<String>> = None;
let mut gossipped_addr: HashSet<String> = Default::default(); let mut gossipped_addr: HashSet<String> = Default::default();
cur1 = (*(*gossip_headers).fld_list).first;
while !cur1.is_null() { for cur_data in (*(*gossip_headers).fld_list).into_iter() {
let field: *mut mailimf_field = (if !cur1.is_null() { let field: *mut mailimf_field = cur_data as *mut _;
(*cur1).data
} else {
ptr::null_mut()
}) as *mut mailimf_field;
if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int { if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
let optional_field: *const mailimf_optional_field = let optional_field = (*field).fld_data.fld_optional_field;
(*field).fld_data.fld_optional_field;
if !optional_field.is_null() if !optional_field.is_null()
&& !(*optional_field).fld_name.is_null() && !(*optional_field).fld_name.is_null()
&& strcasecmp( && strcasecmp(
@@ -701,11 +664,6 @@ unsafe fn update_gossip_peerstates(
} }
} }
} }
cur1 = if !cur1.is_null() {
(*cur1).next
} else {
ptr::null_mut()
}
} }
gossipped_addr gossipped_addr
@@ -722,7 +680,6 @@ unsafe fn decrypt_recursive(
) -> Result<()> { ) -> Result<()> {
ensure!(!mime.is_null(), "Invalid mime reference"); ensure!(!mime.is_null(), "Invalid mime reference");
let ct: *mut mailmime_content; let ct: *mut mailmime_content;
let mut cur: *mut clistiter;
if (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int { if (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int {
ct = (*mime).mm_content_type; ct = (*mime).mm_content_type;
@@ -733,23 +690,18 @@ unsafe fn decrypt_recursive(
b"encrypted\x00" as *const u8 as *const libc::c_char, b"encrypted\x00" as *const u8 as *const libc::c_char,
) == 0i32 ) == 0i32
{ {
cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first; for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
while !cur.is_null() {
let mut decrypted_mime: *mut mailmime = ptr::null_mut(); let mut decrypted_mime: *mut mailmime = ptr::null_mut();
if decrypt_part( if decrypt_part(
context, context,
(if !cur.is_null() { cur_data as *mut mailmime,
(*cur).data
} else {
ptr::null_mut()
}) as *mut mailmime,
private_keyring, private_keyring,
public_keyring_for_validate, public_keyring_for_validate,
ret_valid_signatures, ret_valid_signatures,
&mut decrypted_mime, &mut decrypted_mime,
) { ) {
if (*ret_gossip_headers).is_null() && ret_valid_signatures.len() > 0 { if (*ret_gossip_headers).is_null() && ret_valid_signatures.len() > 0 {
let mut dummy: libc::size_t = 0i32 as libc::size_t; let mut dummy: libc::size_t = 0;
let mut test: *mut mailimf_fields = ptr::null_mut(); let mut test: *mut mailimf_fields = ptr::null_mut();
if mailimf_envelope_and_optional_fields_parse( if mailimf_envelope_and_optional_fields_parse(
(*decrypted_mime).mm_mime_start, (*decrypted_mime).mm_mime_start,
@@ -766,23 +718,13 @@ unsafe fn decrypt_recursive(
mailmime_free(mime); mailmime_free(mime);
return Ok(()); return Ok(());
} }
cur = if !cur.is_null() {
(*cur).next
} else {
ptr::null_mut()
}
} }
*ret_has_unencrypted_parts = 1i32 *ret_has_unencrypted_parts = 1i32
} else { } else {
cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first; for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
while !cur.is_null() {
if decrypt_recursive( if decrypt_recursive(
context, context,
(if !cur.is_null() { cur_data as *mut mailmime,
(*cur).data
} else {
ptr::null_mut()
}) as *mut mailmime,
private_keyring, private_keyring,
public_keyring_for_validate, public_keyring_for_validate,
ret_valid_signatures, ret_valid_signatures,
@@ -793,11 +735,6 @@ unsafe fn decrypt_recursive(
{ {
return Ok(()); return Ok(());
} }
cur = if !cur.is_null() {
(*cur).next
} else {
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 {
@@ -847,27 +784,14 @@ unsafe fn decrypt_part(
|| (*mime_data).dt_data.dt_text.dt_length <= 0) || (*mime_data).dt_data.dt_text.dt_length <= 0)
{ {
if !(*mime).mm_mime_fields.is_null() { if !(*mime).mm_mime_fields.is_null() {
let mut cur: *mut clistiter; for cur_data in (*(*(*mime).mm_mime_fields).fld_list).into_iter() {
cur = (*(*(*mime).mm_mime_fields).fld_list).first; let field: *mut mailmime_field = cur_data as *mut _;
while !cur.is_null() {
let field: *mut mailmime_field = (if !cur.is_null() {
(*cur).data
} else {
ptr::null_mut()
}) as *mut mailmime_field;
if !field.is_null() {
if (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int if (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int
&& !(*field).fld_data.fld_encoding.is_null() && !(*field).fld_data.fld_encoding.is_null()
{ {
mime_transfer_encoding = (*(*field).fld_data.fld_encoding).enc_type mime_transfer_encoding = (*(*field).fld_data.fld_encoding).enc_type
} }
} }
cur = if !cur.is_null() {
(*cur).next
} else {
ptr::null_mut()
}
}
} }
/* regard `Content-Transfer-Encoding:` */ /* regard `Content-Transfer-Encoding:` */
if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int
@@ -992,23 +916,10 @@ unsafe fn contains_report(mime: *mut mailmime) -> bool {
{ {
return true; return true;
} }
let mut cur: *mut clistiter; for cur_data in (*(*(*mime).mm_mime_fields).fld_list).into_iter() {
cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first; if contains_report(cur_data as *mut mailmime) {
while !cur.is_null() {
if contains_report(
(if !cur.is_null() {
(*cur).data
} else {
ptr::null_mut()
}) as *mut mailmime,
) {
return true; return true;
} }
cur = if !cur.is_null() {
(*cur).next
} else {
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 {
if contains_report((*mime).mm_data.mm_message.mm_msg_mime) { if contains_report((*mime).mm_data.mm_message.mm_msg_mime) {