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

Replace dc_array with Vec in dc_receive_imf.rs

Browse Source
This commit is contained in:
Alexander Krotov
2019-08-16 23:24:53 +03:00
committed by holger krekel
parent d946774741
commit 1a42a1e6b1
2 changed files with 62 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
src/dc_receive_imf.rs
View File

@@ -13,7 +13,6 @@ use std::ptr;
use crate::constants::*; use crate::constants::*;
use crate::contact::*; use crate::contact::*;
use crate::context::Context; use crate::context::Context;
use crate::dc_array::*;
use crate::dc_chat::*; use crate::dc_chat::*;
use crate::dc_job::*; use crate::dc_job::*;
use crate::dc_location::*; use crate::dc_location::*;
@@ -86,20 +85,15 @@ pub unsafe fn dc_receive_imf(
let mut create_event_to_send = Some(Event::MSGS_CHANGED); let mut create_event_to_send = Some(Event::MSGS_CHANGED);
let mut rr_event_to_send = Vec::new(); let mut rr_event_to_send = Vec::new();
// XXX converting the below "to_ids" to a Vec quickly leads to lots of changes let mut to_ids = Vec::with_capacity(16);
// so we keep it as a dc_array for now
let to_ids = dc_array_new(16);
assert!(!to_ids.is_null());
// helper method to handle early exit and memory cleanup // helper method to handle early exit and memory cleanup
let cleanup = |context: &Context, let cleanup = |context: &Context,
rfc724_mid: *mut libc::c_char, rfc724_mid: *mut libc::c_char,
to_ids: *mut dc_array_t,
create_event_to_send: &Option<Event>, create_event_to_send: &Option<Event>,
created_db_entries: &Vec<(usize, usize)>, created_db_entries: &Vec<(usize, usize)>,
rr_event_to_send: &Vec<(u32, u32)>| { rr_event_to_send: &Vec<(u32, u32)>| {
free(rfc724_mid.cast()); free(rfc724_mid.cast());
dc_array_unref(to_ids);
if let Some(create_event_to_send) = create_event_to_send { if let Some(create_event_to_send) = create_event_to_send {
for (msg_id, insert_id) in created_db_entries { for (msg_id, insert_id) in created_db_entries {
@@ -126,12 +120,12 @@ pub unsafe fn dc_receive_imf(
let fld_from = (*field).fld_data.fld_from; let fld_from = (*field).fld_data.fld_from;
if !fld_from.is_null() { if !fld_from.is_null() {
let mut check_self = 0; let mut check_self = 0;
let from_list = dc_array_new(16 as size_t); let mut from_list = Vec::with_capacity(16);
dc_add_or_lookup_contacts_by_mailbox_list( dc_add_or_lookup_contacts_by_mailbox_list(
context, context,
(*fld_from).frm_mb_list, (*fld_from).frm_mb_list,
Origin::IncomingUnknownFrom, Origin::IncomingUnknownFrom,
from_list, &mut from_list,
&mut check_self, &mut check_self,
); );
if 0 != check_self { if 0 != check_self {
@@ -139,14 +133,13 @@ pub unsafe fn dc_receive_imf(
if 0 != dc_mimeparser_sender_equals_recipient(&mime_parser) { if 0 != dc_mimeparser_sender_equals_recipient(&mime_parser) {
from_id = DC_CONTACT_ID_SELF as u32; from_id = DC_CONTACT_ID_SELF as u32;
} }
} else if dc_array_get_cnt(from_list) >= 1 { } else if from_list.len() >= 1 {
// if there is no from given, from_id stays 0 which is just fine. These messages // if there is no from given, from_id stays 0 which is just fine. These messages
// are very rare, however, we have to add them to the database (they go to the // are very rare, however, we have to add them to the database (they go to the
// "deaddrop" chat) to avoid a re-download from the server. See also [**] // "deaddrop" chat) to avoid a re-download from the server. See also [**]
from_id = dc_array_get_id(from_list, 0); from_id = from_list[0];
incoming_origin = Contact::get_origin_by_id(context, from_id, &mut from_id_blocked) incoming_origin = Contact::get_origin_by_id(context, from_id, &mut from_id_blocked)
} }
dc_array_unref(from_list);
} }
} }
@@ -164,7 +157,7 @@ pub unsafe fn dc_receive_imf(
} else { } else {
Origin::IncomingUnknownTo Origin::IncomingUnknownTo
}, },
to_ids, &mut to_ids,
&mut to_self, &mut to_self,
); );
} }
@@ -181,7 +174,7 @@ pub unsafe fn dc_receive_imf(
&mut incoming_origin, &mut incoming_origin,
server_folder.as_ref(), server_folder.as_ref(),
server_uid, server_uid,
to_ids, &mut to_ids,
rfc724_mid, rfc724_mid,
&mut sent_timestamp, &mut sent_timestamp,
&mut from_id, &mut from_id,
@@ -201,7 +194,6 @@ pub unsafe fn dc_receive_imf(
cleanup( cleanup(
context, context,
rfc724_mid, rfc724_mid,
to_ids,
&create_event_to_send, &create_event_to_send,
&created_db_entries, &created_db_entries,
&rr_event_to_send, &rr_event_to_send,
@@ -260,7 +252,6 @@ pub unsafe fn dc_receive_imf(
cleanup( cleanup(
context, context,
rfc724_mid, rfc724_mid,
to_ids,
&create_event_to_send, &create_event_to_send,
&created_db_entries, &created_db_entries,
&rr_event_to_send, &rr_event_to_send,
@@ -276,7 +267,7 @@ unsafe fn add_parts(
incoming_origin: &mut Origin, incoming_origin: &mut Origin,
server_folder: impl AsRef<str>, server_folder: impl AsRef<str>,
server_uid: u32, server_uid: u32,
to_ids: *mut dc_array_t, to_ids: &mut Vec<u32>,
mut rfc724_mid: *mut libc::c_char, mut rfc724_mid: *mut libc::c_char,
sent_timestamp: &mut i64, sent_timestamp: &mut i64,
from_id: &mut u32, from_id: &mut u32,
@@ -447,7 +438,7 @@ unsafe fn add_parts(
&mut mime_parser, &mut mime_parser,
allow_creation, allow_creation,
create_blocked, create_blocked,
*from_id as i32, *from_id,
to_ids, to_ids,
chat_id, chat_id,
&mut chat_id_blocked, &mut chat_id_blocked,
@@ -527,15 +518,15 @@ unsafe fn add_parts(
// We cannot recreate other states (read, error). // We cannot recreate other states (read, error).
state = DC_STATE_OUT_DELIVERED; state = DC_STATE_OUT_DELIVERED;
*from_id = DC_CONTACT_ID_SELF as u32; *from_id = DC_CONTACT_ID_SELF as u32;
if dc_array_get_cnt(to_ids) >= 1 { if !to_ids.is_empty() {
*to_id = dc_array_get_id(to_ids, 0); *to_id = to_ids[0];
if *chat_id == 0 { if *chat_id == 0 {
create_or_lookup_group( create_or_lookup_group(
context, context,
&mut mime_parser, &mut mime_parser,
allow_creation, allow_creation,
0, 0,
*from_id as i32, *from_id,
to_ids, to_ids,
chat_id, chat_id,
&mut chat_id_blocked, &mut chat_id_blocked,
@@ -565,7 +556,7 @@ unsafe fn add_parts(
} }
} }
if *chat_id == 0 { if *chat_id == 0 {
if dc_array_get_cnt(to_ids) == 0 && 0 != to_self { if to_ids.is_empty() && 0 != to_self {
// from_id==to_id==DC_CONTACT_ID_SELF - this is a self-sent messages, // from_id==to_id==DC_CONTACT_ID_SELF - this is a self-sent messages,
// maybe an Autocrypt Setup Messag // maybe an Autocrypt Setup Messag
dc_create_or_lookup_nchat_by_contact_id( dc_create_or_lookup_nchat_by_contact_id(
@@ -1053,8 +1044,8 @@ unsafe fn create_or_lookup_group(
mime_parser: &mut dc_mimeparser_t, mime_parser: &mut dc_mimeparser_t,
allow_creation: libc::c_int, allow_creation: libc::c_int,
create_blocked: libc::c_int, create_blocked: libc::c_int,
from_id: int32_t, from_id: u32,
to_ids: *const dc_array_t, to_ids: &mut Vec<u32>,
ret_chat_id: *mut uint32_t, ret_chat_id: *mut uint32_t,
ret_chat_id_blocked: *mut libc::c_int, ret_chat_id_blocked: *mut libc::c_int,
) { ) {
@@ -1064,7 +1055,7 @@ unsafe fn create_or_lookup_group(
let mut chat_id_verified = 0; let mut chat_id_verified = 0;
let mut grpid = std::ptr::null_mut(); let mut grpid = std::ptr::null_mut();
let mut grpname = std::ptr::null_mut(); let mut grpname = std::ptr::null_mut();
let to_ids_cnt = dc_array_get_cnt(to_ids); let to_ids_cnt = to_ids.len();
let mut recreate_member_list = 0; let mut recreate_member_list = 0;
let mut send_EVENT_CHAT_MODIFIED = 0; let mut send_EVENT_CHAT_MODIFIED = 0;
// pointer somewhere into mime_parser, must not be freed // pointer somewhere into mime_parser, must not be freed
@@ -1420,7 +1411,7 @@ unsafe fn create_or_lookup_group(
if skip.is_null() || !addr_cmp(&self_addr, as_str(skip)) { if skip.is_null() || !addr_cmp(&self_addr, as_str(skip)) {
dc_add_to_chat_contacts_table(context, chat_id, DC_CONTACT_ID_SELF as u32); dc_add_to_chat_contacts_table(context, chat_id, DC_CONTACT_ID_SELF as u32);
} }
if from_id > DC_CHAT_ID_LAST_SPECIAL as i32 { if from_id > DC_CHAT_ID_LAST_SPECIAL as u32 {
if !Contact::addr_equals_contact(context, &self_addr, from_id as u32) if !Contact::addr_equals_contact(context, &self_addr, from_id as u32)
&& (skip.is_null() && (skip.is_null()
|| !Contact::addr_equals_contact(context, to_string(skip), from_id as u32)) || !Contact::addr_equals_contact(context, to_string(skip), from_id as u32))
@@ -1428,8 +1419,7 @@ unsafe fn create_or_lookup_group(
dc_add_to_chat_contacts_table(context, chat_id, from_id as u32); dc_add_to_chat_contacts_table(context, chat_id, from_id as u32);
} }
} }
for i in 0..to_ids_cnt { for &to_id in to_ids.iter() {
let to_id = dc_array_get_id(to_ids, i as size_t);
if !Contact::addr_equals_contact(context, &self_addr, to_id) if !Contact::addr_equals_contact(context, &self_addr, to_id)
&& (skip.is_null() && (skip.is_null()
|| !Contact::addr_equals_contact(context, to_string(skip), to_id)) || !Contact::addr_equals_contact(context, to_string(skip), to_id))
@@ -1483,37 +1473,24 @@ unsafe fn create_or_lookup_adhoc_group(
mime_parser: &dc_mimeparser_t, mime_parser: &dc_mimeparser_t,
allow_creation: libc::c_int, allow_creation: libc::c_int,
create_blocked: libc::c_int, create_blocked: libc::c_int,
from_id: int32_t, from_id: u32,
to_ids: *const dc_array_t, to_ids: &mut Vec<u32>,
ret_chat_id: *mut uint32_t, ret_chat_id: *mut uint32_t,
ret_chat_id_blocked: *mut libc::c_int, ret_chat_id_blocked: *mut libc::c_int,
) { ) {
// if we're here, no grpid was found, check there is an existing ad-hoc // if we're here, no grpid was found, check there is an existing ad-hoc
// group matching the to-list or if we can create one // group matching the to-list or if we can create one
let mut member_ids = 0 as *mut dc_array_t;
let mut chat_id = 0; let mut chat_id = 0;
let mut chat_id_blocked = 0; let mut chat_id_blocked = 0;
let mut chat_ids = 0 as *mut dc_array_t;
let mut chat_ids_str = 0 as *mut libc::c_char;
let mut grpid = 0 as *mut libc::c_char; let mut grpid = 0 as *mut libc::c_char;
let mut grpname = 0 as *mut libc::c_char; let mut grpname = 0 as *mut libc::c_char;
let cleanup = |grpid: *mut libc::c_char, let cleanup = |grpid: *mut libc::c_char,
grpname: *mut libc::c_char, grpname: *mut libc::c_char,
chat_ids_str: *mut libc::c_char,
member_ids: *mut dc_array_t,
chat_ids: *mut dc_array_t,
ret_chat_id: *mut uint32_t, ret_chat_id: *mut uint32_t,
ret_chat_id_blocked: *mut libc::c_int, ret_chat_id_blocked: *mut libc::c_int,
chat_id: u32, chat_id: u32,
chat_id_blocked: i32| { chat_id_blocked: i32| {
if !member_ids.is_null() {
dc_array_unref(member_ids);
}
if !chat_ids.is_null() {
dc_array_unref(chat_ids);
}
free(chat_ids_str as *mut libc::c_void);
free(grpid as *mut libc::c_void); free(grpid as *mut libc::c_void);
free(grpname as *mut libc::c_void); free(grpname as *mut libc::c_void);
@@ -1526,14 +1503,11 @@ unsafe fn create_or_lookup_adhoc_group(
}; };
// build member list from the given ids // build member list from the given ids
if dc_array_get_cnt(to_ids) == 0 || 0 != dc_mimeparser_is_mailinglist_message(mime_parser) { if to_ids.is_empty() || 0 != dc_mimeparser_is_mailinglist_message(mime_parser) {
// too few contacts or a mailinglist // too few contacts or a mailinglist
cleanup( cleanup(
grpid, grpid,
grpname, grpname,
chat_ids_str,
member_ids,
chat_ids,
ret_chat_id, ret_chat_id,
ret_chat_id_blocked, ret_chat_id_blocked,
chat_id, chat_id,
@@ -1542,21 +1516,18 @@ unsafe fn create_or_lookup_adhoc_group(
return; return;
} }
member_ids = dc_array_duplicate(to_ids); let mut member_ids = to_ids.clone();
if !dc_array_search_id(member_ids, from_id as uint32_t, 0 as *mut size_t) { if !member_ids.contains(&from_id) {
dc_array_add_id(member_ids, from_id as uint32_t); member_ids.push(from_id);
} }
if !dc_array_search_id(member_ids, 1 as uint32_t, 0 as *mut size_t) { if !member_ids.contains(&1) {
dc_array_add_id(member_ids, 1 as uint32_t); member_ids.push(1);
} }
if dc_array_get_cnt(member_ids) < 3 { if member_ids.len() < 3 {
// too few contacts given // too few contacts given
cleanup( cleanup(
grpid, grpid,
grpname, grpname,
chat_ids_str,
member_ids,
chat_ids,
ret_chat_id, ret_chat_id,
ret_chat_id_blocked, ret_chat_id_blocked,
chat_id, chat_id,
@@ -1565,14 +1536,14 @@ unsafe fn create_or_lookup_adhoc_group(
return; return;
} }
chat_ids = search_chat_ids_by_contact_ids(context, member_ids); let chat_ids = search_chat_ids_by_contact_ids(context, &member_ids);
if dc_array_get_cnt(chat_ids) > 0 { if !chat_ids.is_empty() {
chat_ids_str = dc_array_get_string(chat_ids, b",\x00" as *const u8 as *const _); let chat_ids_str = join(chat_ids.iter().map(|x| x.to_string()), ",");
let res = context.sql.query_row( let res = context.sql.query_row(
format!( format!(
"SELECT c.id, c.blocked FROM chats c \ "SELECT c.id, c.blocked FROM chats c \
LEFT JOIN msgs m ON m.chat_id=c.id WHERE c.id IN({}) ORDER BY m.timestamp DESC, m.id DESC LIMIT 1;", LEFT JOIN msgs m ON m.chat_id=c.id WHERE c.id IN({}) ORDER BY m.timestamp DESC, m.id DESC LIMIT 1;",
as_str(chat_ids_str), chat_ids_str
), ),
params![], params![],
|row| { |row| {
@@ -1587,9 +1558,6 @@ unsafe fn create_or_lookup_adhoc_group(
cleanup( cleanup(
grpid, grpid,
grpname, grpname,
chat_ids_str,
member_ids,
chat_ids,
ret_chat_id, ret_chat_id,
ret_chat_id_blocked, ret_chat_id_blocked,
chat_id, chat_id,
@@ -1603,9 +1571,6 @@ unsafe fn create_or_lookup_adhoc_group(
cleanup( cleanup(
grpid, grpid,
grpname, grpname,
chat_ids_str,
member_ids,
chat_ids,
ret_chat_id, ret_chat_id,
ret_chat_id_blocked, ret_chat_id_blocked,
chat_id, chat_id,
@@ -1618,14 +1583,11 @@ unsafe fn create_or_lookup_adhoc_group(
// create a new ad-hoc group // create a new ad-hoc group
// - there is no need to check if this group exists; otherwise we would have caught it above // - there is no need to check if this group exists; otherwise we would have caught it above
grpid = create_adhoc_grp_id(context, member_ids); grpid = create_adhoc_grp_id(context, &member_ids);
if grpid.is_null() { if grpid.is_null() {
cleanup( cleanup(
grpid, grpid,
grpname, grpname,
chat_ids_str,
member_ids,
chat_ids,
ret_chat_id, ret_chat_id,
ret_chat_id_blocked, ret_chat_id_blocked,
chat_id, chat_id,
@@ -1639,18 +1601,15 @@ unsafe fn create_or_lookup_adhoc_group(
grpname = dc_strdup(mime_parser.subject) grpname = dc_strdup(mime_parser.subject)
} else { } else {
grpname = context grpname = context
.stock_string_repl_int( .stock_string_repl_int(StockMessage::Member, member_ids.len() as libc::c_int)
StockMessage::Member,
dc_array_get_cnt(member_ids) as libc::c_int,
)
.strdup(); .strdup();
} }
// create group record // create group record
chat_id = create_group_record(context, grpid, grpname, create_blocked, 0); chat_id = create_group_record(context, grpid, grpname, create_blocked, 0);
chat_id_blocked = create_blocked; chat_id_blocked = create_blocked;
for i in 0..dc_array_get_cnt(member_ids) { for &member_id in &member_ids {
dc_add_to_chat_contacts_table(context, chat_id, dc_array_get_id(member_ids, i as size_t)); dc_add_to_chat_contacts_table(context, chat_id, member_id);
} }
context.call_cb(Event::CHAT_MODIFIED, chat_id as uintptr_t, 0 as uintptr_t); context.call_cb(Event::CHAT_MODIFIED, chat_id as uintptr_t, 0 as uintptr_t);
@@ -1658,9 +1617,6 @@ unsafe fn create_or_lookup_adhoc_group(
cleanup( cleanup(
grpid, grpid,
grpname, grpname,
chat_ids_str,
member_ids,
chat_ids,
ret_chat_id, ret_chat_id,
ret_chat_id_blocked, ret_chat_id_blocked,
chat_id, chat_id,
@@ -1694,14 +1650,14 @@ fn create_group_record(
sql::get_rowid(context, &context.sql, "chats", "grpid", as_str(grpid)) sql::get_rowid(context, &context.sql, "chats", "grpid", as_str(grpid))
} }
unsafe fn create_adhoc_grp_id(context: &Context, member_ids: *mut dc_array_t) -> *mut libc::c_char { unsafe fn create_adhoc_grp_id(context: &Context, member_ids: &Vec<u32>) -> *mut libc::c_char {
/* algorithm: /* algorithm:
- sort normalized, lowercased, e-mail addresses alphabetically - sort normalized, lowercased, e-mail addresses alphabetically
- put all e-mail addresses into a single string, separate the address by a single comma - put all e-mail addresses into a single string, separate the address by a single comma
- sha-256 this string (without possibly terminating null-characters) - sha-256 this string (without possibly terminating null-characters)
- encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f]) - encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f])
*/ */
let member_ids_str = dc_array_get_string(member_ids, b",\x00" as *const u8 as *const _); let member_ids_str = join(member_ids.iter().map(|x| x.to_string()), ",");
let member_cs = context let member_cs = context
.sql .sql
.get_config(context, "configured_addr") .get_config(context, "configured_addr")
@@ -1713,7 +1669,7 @@ unsafe fn create_adhoc_grp_id(context: &Context, member_ids: *mut dc_array_t) ->
.query_map( .query_map(
format!( format!(
"SELECT addr FROM contacts WHERE id IN({}) AND id!=1", "SELECT addr FROM contacts WHERE id IN({}) AND id!=1",
as_str(member_ids_str) member_ids_str
), ),
params![], params![],
|row| row.get::<_, String>(0), |row| row.get::<_, String>(0),
@@ -1729,7 +1685,6 @@ unsafe fn create_adhoc_grp_id(context: &Context, member_ids: *mut dc_array_t) ->
}, },
) )
.unwrap_or_else(|_| member_cs); .unwrap_or_else(|_| member_cs);
free(member_ids_str as *mut libc::c_void);
hex_hash(&members) as *mut _ hex_hash(&members) as *mut _
} }
@@ -1744,23 +1699,18 @@ fn hex_hash(s: impl AsRef<str>) -> *const libc::c_char {
#[allow(non_snake_case)] #[allow(non_snake_case)]
unsafe fn search_chat_ids_by_contact_ids( unsafe fn search_chat_ids_by_contact_ids(
context: &Context, context: &Context,
unsorted_contact_ids: *const dc_array_t, unsorted_contact_ids: &Vec<u32>,
) -> *mut dc_array_t { ) -> Vec<u32> {
/* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */ /* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
let mut contact_ids = Vec::with_capacity(23); let mut contact_ids = Vec::with_capacity(23);
let mut chat_ids = Vec::with_capacity(23); let mut chat_ids = Vec::with_capacity(23);
/* copy array, remove duplicates and SELF, sort by ID */ /* copy array, remove duplicates and SELF, sort by ID */
let mut i: libc::c_int; if !unsorted_contact_ids.is_empty() {
let iCnt: libc::c_int = dc_array_get_cnt(unsorted_contact_ids) as libc::c_int; for &curr_id in unsorted_contact_ids {
if !(iCnt <= 0) { if curr_id != 1 && !contact_ids.contains(&curr_id) {
i = 0;
while i < iCnt {
let curr_id: uint32_t = dc_array_get_id(unsorted_contact_ids, i as size_t);
if curr_id != 1 as libc::c_uint && !contact_ids.contains(&curr_id) {
contact_ids.push(curr_id); contact_ids.push(curr_id);
} }
i += 1
} }
if !contact_ids.is_empty() { if !contact_ids.is_empty() {
contact_ids.sort(); contact_ids.sort();
@@ -1771,7 +1721,7 @@ unsafe fn search_chat_ids_by_contact_ids(
contact_ids_str contact_ids_str
), ),
params![], params![],
|row| Ok((row.get::<_, i32>(0)?, row.get::<_, i32>(1)?)), |row| Ok((row.get::<_, u32>(0)?, row.get::<_, u32>(1)?)),
|rows| { |rows| {
let mut last_chat_id = 0; let mut last_chat_id = 0;
let mut matches = 0; let mut matches = 0;
@@ -1787,7 +1737,7 @@ unsafe fn search_chat_ids_by_contact_ids(
matches = 0; matches = 0;
mismatches = 0; mismatches = 0;
} }
if contact_id as u32 == contact_ids[matches] { if contact_id == contact_ids[matches] {
matches += 1; matches += 1;
} else { } else {
mismatches += 1; mismatches += 1;
@@ -1803,14 +1753,14 @@ unsafe fn search_chat_ids_by_contact_ids(
} }
} }
dc_array_t::from(chat_ids).into_raw() chat_ids
} }
unsafe fn check_verified_properties( unsafe fn check_verified_properties(
context: &Context, context: &Context,
mimeparser: &dc_mimeparser_t, mimeparser: &dc_mimeparser_t,
from_id: uint32_t, from_id: u32,
to_ids: *const dc_array_t, to_ids: &Vec<u32>,
failure_reason: *mut *mut libc::c_char, failure_reason: *mut *mut libc::c_char,
) -> libc::c_int { ) -> libc::c_int {
let verify_fail = |reason: String| { let verify_fail = |reason: String| {
@@ -1853,15 +1803,13 @@ unsafe fn check_verified_properties(
} }
} }
let to_ids_str_c = dc_array_get_string(to_ids, b",\x00" as *const u8 as *const libc::c_char); let to_ids_str = join(to_ids.iter().map(|x| x.to_string()), ",");
let to_ids_str = to_string(to_ids_str_c);
free(to_ids_str_c as *mut libc::c_void);
let rows = context.sql.query_map( let rows = context.sql.query_map(
format!( format!(
"SELECT c.addr, LENGTH(ps.verified_key_fingerprint) FROM contacts c \ "SELECT c.addr, LENGTH(ps.verified_key_fingerprint) FROM contacts c \
LEFT JOIN acpeerstates ps ON c.addr=ps.addr WHERE c.id IN({}) ", LEFT JOIN acpeerstates ps ON c.addr=ps.addr WHERE c.id IN({}) ",
&to_ids_str, to_ids_str,
), ),
params![], params![],
|row| Ok((row.get::<_, String>(0)?, row.get::<_, i32>(1)?)), |row| Ok((row.get::<_, String>(0)?, row.get::<_, i32>(1)?)),
@@ -2085,7 +2033,7 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list(
context: &Context, context: &Context,
adr_list: *const mailimf_address_list, adr_list: *const mailimf_address_list,
origin: Origin, origin: Origin,
ids: *mut dc_array_t, ids: &mut Vec<u32>,
check_self: *mut libc::c_int, check_self: *mut libc::c_int,
) { ) {
if adr_list.is_null() { if adr_list.is_null() {
@@ -2136,7 +2084,7 @@ unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
context: &Context, context: &Context,
mb_list: *const mailimf_mailbox_list, mb_list: *const mailimf_mailbox_list,
origin: Origin, origin: Origin,
ids: *mut dc_array_t, ids: &mut Vec<u32>,
check_self: *mut libc::c_int, check_self: *mut libc::c_int,
) { ) {
if mb_list.is_null() { if mb_list.is_null() {
@@ -2173,7 +2121,7 @@ unsafe fn add_or_lookup_contact_by_addr(
display_name_enc: *const libc::c_char, display_name_enc: *const libc::c_char,
addr_spec: *const libc::c_char, addr_spec: *const libc::c_char,
origin: Origin, origin: Origin,
ids: *mut dc_array_t, ids: &mut Vec<u32>,
mut check_self: *mut libc::c_int, mut check_self: *mut libc::c_int,
) { ) {
/* is addr_spec equal to SELF? */ /* is addr_spec equal to SELF? */
@@ -2208,8 +2156,8 @@ unsafe fn add_or_lookup_contact_by_addr(
.map(|(id, _)| id) .map(|(id, _)| id)
.unwrap_or_default(); .unwrap_or_default();
if 0 != row_id { if 0 != row_id {
if !dc_array_search_id(ids, row_id, 0 as *mut size_t) { if !ids.contains(&row_id) {
dc_array_add_id(ids, row_id); ids.push(row_id);
} }
}; };
} }

22
src/dc_tools.rs
View File

@@ -9,11 +9,12 @@ use mmime::mailimf_types::*;
use rand::{thread_rng, Rng}; use rand::{thread_rng, Rng};
use crate::context::Context; use crate::context::Context;
use crate::dc_array::*;
use crate::error::Error; use crate::error::Error;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
use itertools::max;
/* Some tools and enhancements to the used libraries, there should be /* Some tools and enhancements to the used libraries, there should be
no references to Context and other "larger" classes here. */ no references to Context and other "larger" classes here. */
/* ** library-private **********************************************************/ /* ** library-private **********************************************************/
@@ -707,29 +708,20 @@ fn encode_66bits_as_base64(v1: u32, v2: u32, fill: u32) -> String {
pub unsafe fn dc_create_incoming_rfc724_mid( pub unsafe fn dc_create_incoming_rfc724_mid(
message_timestamp: i64, message_timestamp: i64,
contact_id_from: uint32_t, contact_id_from: u32,
contact_ids_to: *mut dc_array_t, contact_ids_to: &Vec<u32>,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
if contact_ids_to.is_null() || dc_array_get_cnt(contact_ids_to) == 0 { if contact_ids_to.is_empty() {
return ptr::null_mut(); return ptr::null_mut();
} }
/* find out the largest receiver ID (we could also take the smallest, but it should be unique) */ /* find out the largest receiver ID (we could also take the smallest, but it should be unique) */
let mut i = 0; let largest_id_to = max(contact_ids_to.iter());
let icnt = dc_array_get_cnt(contact_ids_to);
let mut largest_id_to = 0;
while i < icnt {
let cur_id: uint32_t = dc_array_get_id(contact_ids_to, i);
if cur_id > largest_id_to {
largest_id_to = cur_id
}
i = i.wrapping_add(1)
}
dc_mprintf( dc_mprintf(
b"%lu-%lu-%lu@stub\x00" as *const u8 as *const libc::c_char, b"%lu-%lu-%lu@stub\x00" as *const u8 as *const libc::c_char,
message_timestamp as libc::c_ulong, message_timestamp as libc::c_ulong,
contact_id_from as libc::c_ulong, contact_id_from as libc::c_ulong,
largest_id_to as libc::c_ulong, *largest_id_to.unwrap() as libc::c_ulong,
) )
} }