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

it compiles

Browse Source
This commit is contained in:
dignifiedquire
2019-05-01 22:53:42 +02:00
parent 1abc53f757
commit 313f71a004
33 changed files with 2456 additions and 1953 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/dc_apeerstate.rs
View File

@@ -103,7 +103,8 @@ pub unsafe fn dc_apeerstate_recalc_fingerprint(mut peerstate: *mut dc_apeerstate
if !peerstate.is_null() {
if !(*peerstate).public_key.is_null() {
old_public_fingerprint = (*peerstate).public_key_fingerprint;
(*peerstate).public_key_fingerprint = dc_key_get_fingerprint((*peerstate).public_key);
(*peerstate).public_key_fingerprint =
dc_key_get_fingerprint((*peerstate).context, (*peerstate).public_key);
if old_public_fingerprint.is_null()
|| *old_public_fingerprint.offset(0isize) as libc::c_int == 0i32
|| (*peerstate).public_key_fingerprint.is_null()
@@ -120,7 +121,8 @@ pub unsafe fn dc_apeerstate_recalc_fingerprint(mut peerstate: *mut dc_apeerstate
}
if !(*peerstate).gossip_key.is_null() {
old_gossip_fingerprint = (*peerstate).gossip_key_fingerprint;
(*peerstate).gossip_key_fingerprint = dc_key_get_fingerprint((*peerstate).gossip_key);
(*peerstate).gossip_key_fingerprint =
dc_key_get_fingerprint((*peerstate).context, (*peerstate).gossip_key);
if old_gossip_fingerprint.is_null()
|| *old_gossip_fingerprint.offset(0isize) as libc::c_int == 0i32
|| (*peerstate).gossip_key_fingerprint.is_null()
@@ -320,7 +322,9 @@ pub unsafe fn dc_apeerstate_load_by_addr(
if !(peerstate.is_null() || addr.is_null()) {
dc_apeerstate_empty(peerstate);
stmt =
dc_sqlite3_prepare(sql,
dc_sqlite3_prepare(
(*peerstate).context,
sql,
b"SELECT addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint FROM acpeerstates WHERE addr=? COLLATE NOCASE;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, addr, -1i32, None);
@@ -370,8 +374,10 @@ pub unsafe fn dc_apeerstate_load_by_fingerprint(
if !(peerstate.is_null() || fingerprint.is_null()) {
dc_apeerstate_empty(peerstate);
stmt =
dc_sqlite3_prepare(sql,
b"SELECT addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint FROM acpeerstates WHERE public_key_fingerprint=? COLLATE NOCASE OR gossip_key_fingerprint=? COLLATE NOCASE ORDER BY public_key_fingerprint=? DESC;\x00"
dc_sqlite3_prepare(
(*peerstate).context,
sql,
b"SELECT addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint FROM acpeerstates WHERE public_key_fingerprint=? COLLATE NOCASE OR gossip_key_fingerprint=? COLLATE NOCASE ORDER BY public_key_fingerprint=? DESC;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, fingerprint, -1i32, None);
sqlite3_bind_text(stmt, 2i32, fingerprint, -1i32, None);
@@ -397,6 +403,7 @@ pub unsafe fn dc_apeerstate_save_to_db(
}
if 0 != create {
stmt = dc_sqlite3_prepare(
(*peerstate).context,
sql,
b"INSERT INTO acpeerstates (addr) VALUES(?);\x00" as *const u8 as *const libc::c_char,
);
@@ -407,7 +414,8 @@ pub unsafe fn dc_apeerstate_save_to_db(
}
if 0 != (*peerstate).to_save & 0x2i32 || 0 != create {
stmt =
dc_sqlite3_prepare(sql,
dc_sqlite3_prepare(
(*peerstate).context,sql,
b"UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, prefer_encrypted=?, public_key=?, gossip_timestamp=?, gossip_key=?, public_key_fingerprint=?, gossip_key_fingerprint=?, verified_key=?, verified_key_fingerprint=? WHERE addr=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(stmt, 1i32, (*peerstate).last_seen as sqlite3_int64);
@@ -482,7 +490,8 @@ pub unsafe fn dc_apeerstate_save_to_db(
}
} else if 0 != (*peerstate).to_save & 0x1i32 {
stmt =
dc_sqlite3_prepare(sql,
dc_sqlite3_prepare(
(*peerstate).context,sql,
b"UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? WHERE addr=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(stmt, 1i32, (*peerstate).last_seen as sqlite3_int64);

111
src/dc_chat.rs
View File

@@ -123,6 +123,7 @@ pub unsafe fn dc_block_chat(
) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE chats SET blocked=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -138,6 +139,7 @@ pub unsafe fn dc_chat_load_from_db(mut chat: *mut dc_chat_t, mut chat_id: uint32
dc_chat_empty(chat);
stmt =
dc_sqlite3_prepare(
(*chat).context,
&mut (*chat).context.sql.lock().unwrap(),
b"SELECT c.id,c.type,c.name, c.grpid,c.param,c.archived, c.blocked, c.gossiped_timestamp, c.locations_send_until FROM chats c WHERE c.id=?;\x00"
as *const u8 as *const libc::c_char
@@ -325,10 +327,11 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
);
} else {
};
stmt = dc_sqlite3_prepare(&mut context.sql.lock().unwrap(), q);
stmt = dc_sqlite3_prepare(context, &mut context.sql.lock().unwrap(), q);
if !stmt.is_null() {
if !(sqlite3_step(stmt) != 101i32) {
chat_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(),
b"chats\x00" as *const u8 as *const libc::c_char,
b"grpid\x00" as *const u8 as *const libc::c_char,
@@ -344,7 +347,7 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
chat_id,
contact_id,
);
stmt = dc_sqlite3_prepare(&mut context.sql.lock().unwrap(), q);
stmt = dc_sqlite3_prepare(context, &mut context.sql.lock().unwrap(), q);
if !(sqlite3_step(stmt) != 101i32) {
sqlite3_free(q as *mut libc::c_void);
q = 0 as *mut libc::c_char;
@@ -383,6 +386,7 @@ pub unsafe fn dc_lookup_real_nchat_by_contact_id(
}
stmt =
dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT c.id, c.blocked FROM chats c INNER JOIN chats_contacts j ON c.id=j.chat_id WHERE c.type=100 AND c.id>9 AND j.contact_id=?;\x00"
as *const u8 as *const libc::c_char);
@@ -565,6 +569,7 @@ unsafe fn prepare_msg_raw(
);
} else {
let mut from: *mut libc::c_char = dc_sqlite3_get_config(
context,
&mut context.sql.lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -587,6 +592,7 @@ unsafe fn prepare_msg_raw(
free(from as *mut libc::c_void);
if (*chat).type_0 == 100i32 {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT contact_id FROM chats_contacts WHERE chat_id=?;\x00" as *const u8
as *const libc::c_char,
@@ -625,6 +631,7 @@ unsafe fn prepare_msg_raw(
we do not send the message out at all */
do_guarantee_e2ee = 0i32;
e2ee_enabled = dc_sqlite3_get_config_int(
context,
&mut context.sql.lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
@@ -634,7 +641,7 @@ unsafe fn prepare_msg_raw(
let mut can_encrypt: libc::c_int = 1i32;
let mut all_mutual: libc::c_int = 1i32;
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(context, &mut context.sql.lock().unwrap(),
b"SELECT ps.prefer_encrypted, c.addr FROM chats_contacts cc LEFT JOIN contacts c ON cc.contact_id=c.id LEFT JOIN acpeerstates ps ON c.addr=ps.addr WHERE cc.chat_id=? AND cc.contact_id>9;\x00"
as *const u8 as
*const libc::c_char);
@@ -677,6 +684,7 @@ unsafe fn prepare_msg_raw(
do_guarantee_e2ee = 1i32
} else if 0
!= last_msg_in_chat_encrypted(
context,
&mut context.sql.lock().unwrap(),
(*chat).id,
)
@@ -744,6 +752,7 @@ unsafe fn prepare_msg_raw(
if 0 != dc_param_exists((*msg).param, DC_PARAM_SET_LATITUDE as libc::c_int) {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"INSERT INTO locations \
(timestamp,from_id,chat_id, latitude,longitude,independent)\
@@ -776,6 +785,7 @@ unsafe fn prepare_msg_raw(
stmt = 0 as *mut sqlite3_stmt;
location_id = dc_sqlite3_get_rowid2(
context,
&mut context.sql.lock().unwrap(),
b"locations\x00" as *const u8 as *const libc::c_char,
b"timestamp\x00" as *const u8 as *const libc::c_char,
@@ -788,7 +798,8 @@ unsafe fn prepare_msg_raw(
// add message to the database
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"INSERT INTO msgs (rfc724_mid, chat_id, from_id, to_id, timestamp, type, state, txt, param, hidden, mime_in_reply_to, mime_references, location_id) VALUES (?,?,?,?,?, ?,?,?,?,?, ?,?,?);\x00"
as *const u8 as
*const libc::c_char);
@@ -825,6 +836,7 @@ unsafe fn prepare_msg_raw(
);
} else {
msg_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(),
b"msgs\x00" as *const u8 as *const libc::c_char,
b"rfc724_mid\x00" as *const u8 as *const libc::c_char,
@@ -858,7 +870,8 @@ unsafe fn get_parent_mime_headers(
|| parent_references.is_null())
{
stmt =
dc_sqlite3_prepare(&mut (*chat).context.sql.lock().unwrap(),
dc_sqlite3_prepare(
(*chat).context,&mut (*chat).context.sql.lock().unwrap(),
b"SELECT rfc724_mid, mime_in_reply_to, mime_references FROM msgs WHERE timestamp=(SELECT max(timestamp) FROM msgs WHERE chat_id=? AND from_id!=?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, (*chat).id as libc::c_int);
@@ -873,7 +886,8 @@ unsafe fn get_parent_mime_headers(
stmt = 0 as *mut sqlite3_stmt;
if 0 == success {
stmt =
dc_sqlite3_prepare(&mut (*chat).context.sql.lock().unwrap(),
dc_sqlite3_prepare(
(*chat).context,&mut (*chat).context.sql.lock().unwrap(),
b"SELECT rfc724_mid, mime_in_reply_to, mime_references FROM msgs WHERE timestamp=(SELECT min(timestamp) FROM msgs WHERE chat_id=? AND from_id==?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, (*chat).id as libc::c_int);
@@ -902,12 +916,14 @@ pub unsafe fn dc_chat_is_self_talk(mut chat: *const dc_chat_t) -> libc::c_int {
* Sending messages
******************************************************************************/
unsafe fn last_msg_in_chat_encrypted(
mut sql: &mut dc_sqlite3_t,
mut chat_id: uint32_t,
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
chat_id: uint32_t,
) -> libc::c_int {
let mut last_is_encrypted: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt =
dc_sqlite3_prepare(sql,
dc_sqlite3_prepare(
context,sql,
b"SELECT param FROM msgs WHERE timestamp=(SELECT MAX(timestamp) FROM msgs WHERE chat_id=?) ORDER BY id DESC;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -928,6 +944,7 @@ unsafe fn last_msg_in_chat_encrypted(
pub unsafe fn dc_chat_update_param(mut chat: *mut dc_chat_t) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
(*chat).context,
&mut (*chat).context.sql.lock().unwrap(),
b"UPDATE chats SET param=? WHERE id=?\x00" as *const u8 as *const libc::c_char,
);
@@ -952,6 +969,7 @@ pub unsafe fn dc_is_contact_in_chat(
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT contact_id FROM chats_contacts WHERE chat_id=? AND contact_id=?;\x00" as *const u8
as *const libc::c_char,
@@ -970,6 +988,7 @@ pub unsafe fn dc_is_contact_in_chat(
pub unsafe fn dc_unarchive_chat(mut context: &dc_context_t, mut chat_id: uint32_t) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE chats SET archived=0 WHERE id=?\x00" as *const u8 as *const libc::c_char,
);
@@ -1116,7 +1135,8 @@ unsafe fn set_draft_raw(
14513523936503887211 => {}
_ => {
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"INSERT INTO msgs (chat_id, from_id, timestamp, type, state, txt, param, hidden) VALUES (?,?,?, ?,?,?,?,?);\x00"
as *const u8 as
*const libc::c_char);
@@ -1151,6 +1171,7 @@ unsafe fn set_draft_raw(
unsafe fn get_draft_msg_id(mut context: &dc_context_t, mut chat_id: uint32_t) -> uint32_t {
let mut draft_msg_id: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT id FROM msgs WHERE chat_id=? AND state=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1197,23 +1218,27 @@ pub unsafe fn dc_get_chat_msgs(
if !ret.is_null() {
if chat_id == 1i32 as libc::c_uint {
let mut show_emails: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.lock().unwrap(),
b"show_emails\x00" as *const u8 as *const libc::c_char,
0i32,
);
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN chats ON m.chat_id=chats.id LEFT JOIN contacts ON m.from_id=contacts.id WHERE m.from_id!=1 AND m.from_id!=2 AND m.hidden=0 AND chats.blocked=2 AND contacts.blocked=0 AND m.msgrmsg>=? ORDER BY m.timestamp,m.id;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, if show_emails == 2i32 { 0i32 } else { 1i32 });
} else if chat_id == 5i32 as libc::c_uint {
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id WHERE m.starred=1 AND m.hidden=0 AND ct.blocked=0 ORDER BY m.timestamp,m.id;\x00"
as *const u8 as *const libc::c_char)
} else {
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"SELECT m.id, m.timestamp FROM msgs m WHERE m.chat_id=? AND m.hidden=0 ORDER BY m.timestamp,m.id;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -1249,6 +1274,7 @@ pub unsafe fn dc_get_msg_cnt(mut context: &dc_context_t, mut chat_id: uint32_t)
let mut ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM msgs WHERE chat_id=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1267,6 +1293,7 @@ pub unsafe fn dc_get_fresh_msg_cnt(
let mut ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM msgs WHERE state=10 AND hidden=0 AND chat_id=?;\x00"
as *const u8 as *const libc::c_char,
@@ -1283,6 +1310,7 @@ pub unsafe fn dc_marknoticed_chat(mut context: &dc_context_t, mut chat_id: uint3
let mut update: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
check = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT id FROM msgs WHERE chat_id=? AND state=10;\x00" as *const u8
as *const libc::c_char,
@@ -1290,6 +1318,7 @@ pub unsafe fn dc_marknoticed_chat(mut context: &dc_context_t, mut chat_id: uint3
sqlite3_bind_int(check, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(check) != 100i32) {
update = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE chat_id=? AND state=10;\x00" as *const u8
as *const libc::c_char,
@@ -1312,11 +1341,13 @@ pub unsafe fn dc_marknoticed_all_chats(mut context: &dc_context_t) {
let mut update: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
check = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT id FROM msgs WHERE state=10;\x00" as *const u8 as *const libc::c_char,
);
if !(sqlite3_step(check) != 100i32) {
update = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE state=10;\x00" as *const u8 as *const libc::c_char,
);
@@ -1341,7 +1372,8 @@ pub unsafe fn dc_get_chat_media(
) -> *mut dc_array_t {
let mut ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
let mut stmt: *mut sqlite3_stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"SELECT id FROM msgs WHERE chat_id=? AND (type=? OR type=? OR type=?) ORDER BY timestamp, id;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -1432,6 +1464,7 @@ pub unsafe fn dc_archive_chat(
}
if 0 != archive {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE chat_id=? AND state=10;\x00" as *const u8
as *const libc::c_char,
@@ -1441,6 +1474,7 @@ pub unsafe fn dc_archive_chat(
sqlite3_finalize(stmt);
}
let mut stmt_0: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE chats SET archived=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1457,25 +1491,23 @@ pub unsafe fn dc_archive_chat(
}
pub unsafe fn dc_delete_chat(mut context: &dc_context_t, mut chat_id: uint32_t) {
/* Up to 2017-11-02 deleting a group also implied leaving it, see above why we have changed this. */
let mut pending_transaction: libc::c_int = 0i32;
let mut obj: *mut dc_chat_t = dc_chat_new(context);
let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
if !(chat_id <= 9i32 as libc::c_uint) {
if !(0 == dc_chat_load_from_db(obj, chat_id)) {
pending_transaction = 1i32;
q3 = sqlite3_mprintf(
b"DELETE FROM msgs_mdns WHERE msg_id IN (SELECT id FROM msgs WHERE chat_id=%i);\x00"
as *const u8 as *const libc::c_char,
chat_id,
);
if !(0 == dc_sqlite3_execute(&mut context.sql.lock().unwrap(), q3)) {
if !(0 == dc_sqlite3_execute(context, &mut context.sql.lock().unwrap(), q3)) {
sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char;
q3 = sqlite3_mprintf(
b"DELETE FROM msgs WHERE chat_id=%i;\x00" as *const u8 as *const libc::c_char,
chat_id,
);
if !(0 == dc_sqlite3_execute(&mut context.sql.lock().unwrap(), q3)) {
if !(0 == dc_sqlite3_execute(context, &mut context.sql.lock().unwrap(), q3)) {
sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char;
q3 = sqlite3_mprintf(
@@ -1483,7 +1515,7 @@ pub unsafe fn dc_delete_chat(mut context: &dc_context_t, mut chat_id: uint32_t)
as *const libc::c_char,
chat_id,
);
if !(0 == dc_sqlite3_execute(&mut context.sql.lock().unwrap(), q3)) {
if !(0 == dc_sqlite3_execute(context, &mut context.sql.lock().unwrap(), q3)) {
sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char;
q3 = sqlite3_mprintf(
@@ -1491,10 +1523,10 @@ pub unsafe fn dc_delete_chat(mut context: &dc_context_t, mut chat_id: uint32_t)
as *const libc::c_char,
chat_id,
);
if !(0 == dc_sqlite3_execute(&mut context.sql.lock().unwrap(), q3)) {
if !(0 == dc_sqlite3_execute(context, &mut context.sql.lock().unwrap(), q3))
{
sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char;
pending_transaction = 0i32;
(context.cb)(
context,
Event::MSGS_CHANGED,
@@ -1524,7 +1556,8 @@ pub unsafe fn dc_get_chat_contacts(
if !(chat_id == 1i32 as libc::c_uint) {
/* we could also create a list for all contacts in the deaddrop by searching contacts belonging to chats with chats.blocked=2, however, currently this is not needed */
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"SELECT cc.contact_id FROM chats_contacts cc LEFT JOIN contacts c ON c.id=cc.contact_id WHERE cc.chat_id=? ORDER BY c.id=1, LOWER(c.name||c.addr), c.id;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -1568,6 +1601,7 @@ pub unsafe fn dc_create_group_chat(
draft_txt = dc_stock_str_repl_string(context, 14i32, chat_name);
grpid = dc_create_id();
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"INSERT INTO chats (type, name, grpid, param) VALUES(?, ?, ?, \'U=1\');\x00" as *const u8
as *const libc::c_char,
@@ -1577,6 +1611,7 @@ pub unsafe fn dc_create_group_chat(
sqlite3_bind_text(stmt, 3i32, grpid, -1i32, None);
if !(sqlite3_step(stmt) != 101i32) {
chat_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(),
b"chats\x00" as *const u8 as *const libc::c_char,
b"grpid\x00" as *const u8 as *const libc::c_char,
@@ -1614,6 +1649,7 @@ pub unsafe fn dc_add_to_chat_contacts_table(
/* add a contact to a chat; the function does not check the type or if any of the record exist or are already added to the chat! */
let mut ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"INSERT INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)\x00" as *const u8
as *const libc::c_char,
@@ -1671,6 +1707,7 @@ pub unsafe fn dc_add_contact_to_chat_ex(
dc_chat_update_param(chat);
}
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
@@ -1762,6 +1799,7 @@ unsafe fn real_group_exists(mut context: &dc_context_t, mut chat_id: uint32_t) -
return 0i32;
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT id FROM chats WHERE id=? AND (type=120 OR type=130);\x00" as *const u8
as *const libc::c_char,
@@ -1791,6 +1829,7 @@ pub unsafe fn dc_set_gossiped_timestamp(
timestamp as libc::c_int,
);
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE chats SET gossiped_timestamp=? WHERE id=?;\x00" as *const u8
as *const libc::c_char,
@@ -1805,6 +1844,7 @@ pub unsafe fn dc_set_gossiped_timestamp(
timestamp as libc::c_int,
);
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE chats SET gossiped_timestamp=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1879,7 +1919,7 @@ pub unsafe fn dc_remove_contact_from_chat(
chat_id,
contact_id,
);
if !(0 == dc_sqlite3_execute(&mut context.sql.lock().unwrap(), q3)) {
if !(0 == dc_sqlite3_execute(context, &mut context.sql.lock().unwrap(), q3)) {
(context.cb)(
context,
Event::CHAT_MODIFIED,
@@ -1903,6 +1943,7 @@ pub unsafe fn dc_set_group_explicitly_left(
) {
if 0 == dc_is_group_explicitly_left(context, grpid) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"INSERT INTO leftgrps (grpid) VALUES(?);\x00" as *const u8 as *const libc::c_char,
);
@@ -1916,6 +1957,7 @@ pub unsafe fn dc_is_group_explicitly_left(
mut grpid: *const libc::c_char,
) -> libc::c_int {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT id FROM leftgrps WHERE grpid=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1959,7 +2001,7 @@ pub unsafe fn dc_set_chat_name(
new_name,
chat_id,
);
if !(0 == dc_sqlite3_execute(&mut context.sql.lock().unwrap(), q3)) {
if !(0 == dc_sqlite3_execute(context, &mut context.sql.lock().unwrap(), q3)) {
if dc_param_get_int((*chat).param, 'U' as i32, 0i32) == 0i32 {
(*msg).type_0 = 10i32;
(*msg).text = dc_stock_system_msg(
@@ -2081,11 +2123,9 @@ pub unsafe fn dc_forward_msgs(
mut msg_cnt: libc::c_int,
mut chat_id: uint32_t,
) {
let mut current_block: u64;
let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
let mut chat: *mut dc_chat_t = dc_chat_new(context);
let mut contact: *mut dc_contact_t = dc_contact_new(context);
let mut transaction_pending: libc::c_int = 0i32;
let mut created_db_entries: *mut carray = carray_new(16i32 as libc::c_uint);
let mut idsstr: *mut libc::c_char = 0 as *mut libc::c_char;
let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -2093,7 +2133,6 @@ pub unsafe fn dc_forward_msgs(
let mut curr_timestamp: time_t = 0i32 as time_t;
let mut original_param: *mut dc_param_t = dc_param_new();
if !(msg_ids.is_null() || msg_cnt <= 0i32 || chat_id <= 9i32 as libc::c_uint) {
transaction_pending = 1i32;
dc_unarchive_chat(context, chat_id);
context.smtp.lock().unwrap().log_connect_errors = 1i32;
if !(0 == dc_chat_load_from_db(chat, chat_id)) {
@@ -2104,15 +2143,13 @@ pub unsafe fn dc_forward_msgs(
as *const libc::c_char,
idsstr,
);
stmt = dc_sqlite3_prepare(&mut context.sql.lock().unwrap(), q3);
stmt = dc_sqlite3_prepare(context, &mut context.sql.lock().unwrap(), q3);
loop {
if !(sqlite3_step(stmt) == 100i32) {
current_block = 10758786907990354186;
break;
}
let mut src_msg_id: libc::c_int = sqlite3_column_int(stmt, 0i32);
if 0 == dc_msg_load_from_db(msg, context, src_msg_id as uint32_t) {
current_block = 2015322633586469911;
break;
}
dc_param_set_packed(original_param, (*(*msg).param).packed);
@@ -2163,10 +2200,6 @@ pub unsafe fn dc_forward_msgs(
0 as *mut libc::c_uint,
);
}
match current_block {
2015322633586469911 => {}
_ => transaction_pending = 0i32,
}
}
}
if !created_db_entries.is_null() {
@@ -2220,7 +2253,8 @@ pub unsafe extern "C" fn dc_chat_get_subtitle(mut chat: *const dc_chat_t) -> *mu
} else if (*chat).type_0 == 100i32 {
let mut r: libc::c_int = 0;
let mut stmt: *mut sqlite3_stmt =
dc_sqlite3_prepare(&mut (*chat).context.sql.lock().unwrap(),
dc_sqlite3_prepare(
(*chat).context,&mut (*chat).context.sql.lock().unwrap(),
b"SELECT c.addr FROM chats_contacts cc LEFT JOIN contacts c ON c.id=cc.contact_id WHERE cc.chat_id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, (*chat).id as libc::c_int);
@@ -2250,6 +2284,7 @@ pub unsafe fn dc_get_chat_contact_cnt(
) -> libc::c_int {
let mut ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;\x00" as *const u8
as *const libc::c_char,
@@ -2338,6 +2373,7 @@ pub unsafe fn dc_get_chat_cnt(mut context: &dc_context_t) -> size_t {
if !(*context.sql.lock().unwrap()).cobj.is_null() {
/* no database, no chats - this is no error (needed eg. for information) */
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM chats WHERE id>9 AND blocked=0;\x00" as *const u8
as *const libc::c_char,
@@ -2365,6 +2401,7 @@ pub unsafe fn dc_get_chat_id_by_grpid(
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT id, blocked, type FROM chats WHERE grpid=?;\x00" as *const u8
as *const libc::c_char,
@@ -2396,7 +2433,8 @@ pub unsafe fn dc_add_device_msg(
);
if !text.is_null() {
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.lock().unwrap(),
b"INSERT INTO msgs (chat_id,from_id,to_id, timestamp,type,state, txt,rfc724_mid) VALUES (?,?,?, ?,?,?, ?,?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -2413,6 +2451,7 @@ pub unsafe fn dc_add_device_msg(
sqlite3_bind_text(stmt, 8i32, rfc724_mid, -1i32, None);
if !(sqlite3_step(stmt) != 101i32) {
msg_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(),
b"msgs\x00" as *const u8 as *const libc::c_char,
b"rfc724_mid\x00" as *const u8 as *const libc::c_char,

32
src/dc_chatlist.rs
View File

@@ -143,15 +143,20 @@ unsafe fn dc_chatlist_load_from_db(
// shown at all permanent in the chatlist.
if 0 != query_contact_id {
stmt =
dc_sqlite3_prepare(&mut (*chatlist).context.sql.lock().unwrap(),
b"SELECT c.id, m.id FROM chats c LEFT JOIN msgs m ON c.id=m.chat_id AND m.timestamp=( SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 AND c.blocked=0 AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?) GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00"
as *const u8 as *const libc::c_char);
dc_sqlite3_prepare(
(*chatlist).context,
&mut (*chatlist).context.sql.lock().unwrap(),
b"SELECT c.id, m.id FROM chats c LEFT JOIN msgs m ON c.id=m.chat_id AND m.timestamp=( SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 AND c.blocked=0 AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?) GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00"
as *const u8 as *const libc::c_char
);
sqlite3_bind_int(stmt, 1i32, query_contact_id as libc::c_int);
current_block = 3437258052017859086;
} else if 0 != listflags & 0x1i32 {
stmt =
dc_sqlite3_prepare(&mut (*chatlist).context.sql.lock().unwrap(),
b"SELECT c.id, m.id FROM chats c LEFT JOIN msgs m ON c.id=m.chat_id AND m.timestamp=( SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 AND c.blocked=0 AND c.archived=1 GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00"
dc_sqlite3_prepare(
(*chatlist).context,
&mut (*chatlist).context.sql.lock().unwrap(),
b"SELECT c.id, m.id FROM chats c LEFT JOIN msgs m ON c.id=m.chat_id AND m.timestamp=( SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 AND c.blocked=0 AND c.archived=1 GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00"
as *const u8 as *const libc::c_char);
current_block = 3437258052017859086;
} else if query__.is_null() {
@@ -165,7 +170,9 @@ unsafe fn dc_chatlist_load_from_db(
add_archived_link_item = 1i32
}
stmt =
dc_sqlite3_prepare(&mut (*chatlist).context.sql.lock().unwrap(),
dc_sqlite3_prepare(
(*chatlist).context,
&mut (*chatlist).context.sql.lock().unwrap(),
b"SELECT c.id, m.id FROM chats c LEFT JOIN msgs m ON c.id=m.chat_id AND m.timestamp=( SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 AND c.blocked=0 AND c.archived=0 GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00"
as *const u8 as *const libc::c_char);
current_block = 3437258052017859086;
@@ -178,8 +185,10 @@ unsafe fn dc_chatlist_load_from_db(
} else {
strLikeCmd = dc_mprintf(b"%%%s%%\x00" as *const u8 as *const libc::c_char, query);
stmt =
dc_sqlite3_prepare(&mut (*chatlist).context.sql.lock().unwrap(),
b"SELECT c.id, m.id FROM chats c LEFT JOIN msgs m ON c.id=m.chat_id AND m.timestamp=( SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 AND c.blocked=0 AND c.name LIKE ? GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00"
dc_sqlite3_prepare(
(*chatlist).context,
&mut (*chatlist).context.sql.lock().unwrap(),
b"SELECT c.id, m.id FROM chats c LEFT JOIN msgs m ON c.id=m.chat_id AND m.timestamp=( SELECT MAX(timestamp) FROM msgs WHERE chat_id=c.id AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 AND c.blocked=0 AND c.name LIKE ? GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00"
as *const u8 as
*const libc::c_char);
sqlite3_bind_text(stmt, 1i32, strLikeCmd, -1i32, None);
@@ -223,6 +232,7 @@ unsafe fn dc_chatlist_load_from_db(
pub unsafe fn dc_get_archived_cnt(mut context: &dc_context_t) -> libc::c_int {
let mut ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;\x00" as *const u8
as *const libc::c_char,
@@ -237,8 +247,10 @@ unsafe fn get_last_deaddrop_fresh_msg(mut context: &dc_context_t) -> uint32_t {
let mut ret: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(),
b"SELECT m.id FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE m.state=10 AND m.hidden=0 AND c.blocked=2 ORDER BY m.timestamp DESC, m.id DESC;\x00"
dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"SELECT m.id FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE m.state=10 AND m.hidden=0 AND c.blocked=2 ORDER BY m.timestamp DESC, m.id DESC;\x00"
as *const u8 as *const libc::c_char);
/* we have an index over the state-column, this should be sufficient as there are typically only few fresh messages */
if !(sqlite3_step(stmt) != 100i32) {

176
src/dc_configure.rs
View File

@@ -72,7 +72,9 @@ pub unsafe fn dc_configure(mut context: &dc_context_t) {
dc_job_add(context, 900i32, 0i32, 0 as *const libc::c_char, 0i32);
}
pub unsafe fn dc_has_ongoing(mut context: &dc_context_t) -> libc::c_int {
return if 0 != (*context).ongoing_running || (*context).shall_stop_ongoing == 0i32 {
return if 0 != context.ongoing_running
|| *context.shall_stop_ongoing.clone().read().unwrap() == 0
{
1i32
} else {
0i32
@@ -81,6 +83,7 @@ pub unsafe fn dc_has_ongoing(mut context: &dc_context_t) -> libc::c_int {
pub unsafe fn dc_is_configured(mut context: &dc_context_t) -> libc::c_int {
return if 0
!= dc_sqlite3_get_config_int(
context,
&mut context.sql.lock().unwrap(),
b"configured\x00" as *const u8 as *const libc::c_char,
0i32,
@@ -90,14 +93,14 @@ pub unsafe fn dc_is_configured(mut context: &dc_context_t) -> libc::c_int {
0i32
};
}
pub unsafe fn dc_stop_ongoing_process(mut context: &dc_context_t) {
if 0 != (*context).ongoing_running && (*context).shall_stop_ongoing == 0i32 {
pub unsafe fn dc_stop_ongoing_process(context: &dc_context_t) {
if 0 != context.ongoing_running && *context.shall_stop_ongoing.clone().read().unwrap() == 0 {
dc_log_info(
context,
0i32,
b"Signaling the ongoing process to stop ASAP.\x00" as *const u8 as *const libc::c_char,
);
(*context).shall_stop_ongoing = 1i32
*context.shall_stop_ongoing.clone().write().unwrap() = 1;
} else {
dc_log_info(
context,
@@ -133,17 +136,36 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
dc_imap_disconnect(context, &mut context.inbox.clone().lock().unwrap());
dc_imap_disconnect(
context,
&mut context.sentbox_thread.imap.clone().lock().unwrap(),
&mut context
.sentbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
);
dc_imap_disconnect(
context,
&mut context.mvbox_thread.imap.clone().lock().unwrap(),
&mut context
.mvbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
);
dc_smtp_disconnect(&mut context.smtp.clone().lock().unwrap());
context.smtp.clone().lock().unwrap().log_connect_errors = 1i32;
context.inbox.clone().lock().unwrap().log_connect_errors = 1i32;
context
.sentbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
@@ -151,6 +173,9 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
.log_connect_errors = 1i32;
context
.mvbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
@@ -161,7 +186,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
0i32,
b"Configure ...\x00" as *const u8 as *const libc::c_char,
);
if !(0 != context.shall_stop_ongoing) {
if !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
(context.cb)(
context,
Event::CONFIGURE_PROGRESS,
@@ -176,6 +201,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
);
param = dc_loginparam_new();
dc_loginparam_read(
context,
param,
&mut context.sql.lock().unwrap(),
b"\x00" as *const u8 as *const libc::c_char,
@@ -192,7 +218,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
// the used oauth2 addr may differ, check this.
// if dc_get_oauth2_addr() is not available in the oauth2 implementation,
// just use the given one.
if 0 != context.shall_stop_ongoing {
if 0 != *context.shall_stop_ongoing.clone().read().unwrap() {
current_block = 2927484062889439186;
} else {
(context.cb)(
@@ -219,7 +245,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
(*param).addr,
);
}
if 0 != context.shall_stop_ongoing {
if 0 != *context.shall_stop_ongoing.clone().read().unwrap() {
current_block = 2927484062889439186;
} else {
(context.cb)(
@@ -258,7 +284,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
if (*param).mail_pw.is_null() {
(*param).mail_pw = dc_strdup(0 as *const libc::c_char)
}
if !(0 != context.shall_stop_ongoing) {
if !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
(context.cb)(
context,
Event::CONFIGURE_PROGRESS,
@@ -299,7 +325,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
param_autoconfig =
moz_autoconfigure(context, url, param);
free(url as *mut libc::c_void);
if 0 != context.shall_stop_ongoing {
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block = 2927484062889439186;
} else {
(context.cb)(
@@ -337,7 +368,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
param_autoconfig =
moz_autoconfigure(context, url_0, param);
free(url_0 as *mut libc::c_void);
if 0 != context.shall_stop_ongoing {
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block = 2927484062889439186;
} else {
(context.cb)(
@@ -399,7 +435,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
context, url_1, param,
);
free(url_1 as *mut libc::c_void);
if 0 != context.shall_stop_ongoing {
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block =
2927484062889439186;
break;
@@ -442,8 +483,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
free(
url_2 as *mut libc::c_void,
);
if 0 != context
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block =
2927484062889439186;
@@ -500,8 +544,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
free(url_3
as
*mut libc::c_void);
if 0 != context
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block
=
@@ -562,7 +609,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
*mut libc::c_void);
if 0
!=
context.shall_stop_ongoing
*context.shall_stop_ongoing.clone().read().unwrap()
{
current_block
=
@@ -787,7 +834,13 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
b"Account settings incomplete.\x00" as *const u8
as *const libc::c_char,
);
} else if !(0 != context.shall_stop_ongoing) {
} else if !(0
!= *context
.shall_stop_ongoing
.clone()
.read()
.unwrap())
{
(context.cb)(
context,
Event::CONFIGURE_PROGRESS,
@@ -832,7 +885,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
break;
}
// probe STARTTLS/993
if 0 != context.shall_stop_ongoing {
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block = 2927484062889439186;
break;
}
@@ -876,7 +934,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
break;
}
// probe STARTTLS/143
if 0 != context.shall_stop_ongoing {
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block = 2927484062889439186;
break;
}
@@ -922,7 +985,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
break;
}
// next probe round with only the localpart of the email-address as the loginname
if 0 != context.shall_stop_ongoing {
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block = 2927484062889439186;
break;
}
@@ -963,7 +1031,13 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
2927484062889439186 => {}
_ => {
imap_connected_here = 1i32;
if !(0 != context.shall_stop_ongoing) {
if !(0
!= *context
.shall_stop_ongoing
.clone()
.read()
.unwrap())
{
(context.cb)(
context,
Event::CONFIGURE_PROGRESS,
@@ -979,6 +1053,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
);
/* try to connect to SMTP - if we did not got an autoconfig, the first try was SSL-465 and we do a second try with STARTTLS-587 */
if 0 == dc_smtp_connect(
context,
&mut context
.smtp
.clone()
@@ -990,7 +1065,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
current_block =
2927484062889439186;
} else if 0
!= context.shall_stop_ongoing
!= *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block =
2927484062889439186;
@@ -1029,6 +1108,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
);
free(r_3 as *mut libc::c_void);
if 0 == dc_smtp_connect(
context,
&mut context
.smtp
.clone()
@@ -1036,8 +1116,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
.unwrap(),
param,
) {
if 0 != context
if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block =
2927484062889439186;
@@ -1087,6 +1170,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
as
*mut libc::c_void);
if 0 == dc_smtp_connect(
context,
&mut context
.smtp
.clone()
@@ -1116,8 +1200,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
_ => {
smtp_connected_here = 1i32;
if !(0
!= context
.shall_stop_ongoing)
!= *context
.shall_stop_ongoing
.clone()
.read()
.unwrap())
{
(context.cb)(context,
Event::CONFIGURE_PROGRESS,
@@ -1143,7 +1230,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
=
if 0
!=
dc_sqlite3_get_config_int(&mut context.sql.lock().unwrap(),
dc_sqlite3_get_config_int(context, &mut context.sql.lock().unwrap(),
b"mvbox_watch\x00"
as
*const u8
@@ -1153,7 +1240,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
||
0
!=
dc_sqlite3_get_config_int(&mut context.sql.lock().unwrap(),
dc_sqlite3_get_config_int(context, &mut context.sql.lock().unwrap(),
b"mvbox_move\x00"
as
*const u8
@@ -1175,8 +1262,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
flags,
);
if !(0
!= context
.shall_stop_ongoing)
!= *context
.shall_stop_ongoing
.clone()
.read()
.unwrap())
{
(context.cb)(context,
Event::CONFIGURE_PROGRESS,
@@ -1198,22 +1288,25 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
0i32
as
uintptr_t);
dc_loginparam_write(param,
dc_loginparam_write(context, param,
&mut context.sql.lock().unwrap(),
b"configured_\x00"
as
*const u8
as
*const libc::c_char);
dc_sqlite3_set_config_int(&mut context.sql.lock().unwrap(),
dc_sqlite3_set_config_int(context, &mut context.sql.lock().unwrap(),
b"configured\x00"
as
*const u8
as
*const libc::c_char,
1i32);
if !(0 != context
.shall_stop_ongoing)
if !(0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap())
{
(context.cb)(context,
Event::CONFIGURE_PROGRESS,
@@ -1246,7 +1339,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
*const libc::c_char);
if !(0
!=
context.shall_stop_ongoing)
*context.shall_stop_ongoing.clone().read().unwrap())
{
(context.cb)(context,
Event::CONFIGURE_PROGRESS,
@@ -1311,9 +1404,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
}
pub unsafe fn dc_free_ongoing(mut context: &dc_context_t) {
context.ongoing_running = 0i32;
context.shall_stop_ongoing = 1i32;
// FIXME
// context.ongoing_running = 0i32;
*context.shall_stop_ongoing.clone().write().unwrap() = 1;
}
pub unsafe fn dc_configure_folders(
context: &dc_context_t,
imap: &mut dc_imap_t,
@@ -1409,6 +1504,7 @@ pub unsafe fn dc_configure_folders(
mailimap_subscribe((*imap).etpan, mvbox_folder);
}
dc_sqlite3_set_config_int(
context,
&mut context.sql.lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char,
3i32,
@@ -2067,10 +2163,12 @@ pub unsafe fn dc_alloc_ongoing(context: &dc_context_t) -> libc::c_int {
);
return 0i32;
}
context.ongoing_running = 1i32;
context.shall_stop_ongoing = 0i32;
// FIXME
// context.ongoing_running = 1i32;
*context.shall_stop_ongoing.clone().write().unwrap() = 0;
return 1i32;
}
pub unsafe fn dc_connect_to_configured_imap(
context: &dc_context_t,
imap: &mut dc_imap_t,
@@ -2080,6 +2178,7 @@ pub unsafe fn dc_connect_to_configured_imap(
if 0 != dc_imap_is_connected(imap) {
ret_connected = 1i32
} else if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured\x00" as *const u8 as *const libc::c_char,
0i32,
@@ -2092,6 +2191,7 @@ pub unsafe fn dc_connect_to_configured_imap(
);
} else {
dc_loginparam_read(
context,
param,
&mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char,

59
src/dc_contact.rs
View File

@@ -31,6 +31,7 @@ pub struct dc_contact_t<'a> {
pub unsafe fn dc_marknoticed_contact(context: &dc_context_t, contact_id: uint32_t) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE from_id=? AND state=10;\x00" as *const u8
as *const libc::c_char,
@@ -75,6 +76,7 @@ pub unsafe fn dc_lookup_contact_id_by_addr(
if !(addr.is_null() || *addr.offset(0isize) as libc::c_int == 0i32) {
addr_normalized = dc_addr_normalize(addr);
addr_self = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
@@ -83,7 +85,8 @@ pub unsafe fn dc_lookup_contact_id_by_addr(
contact_id = 1i32
} else {
stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM contacts WHERE addr=?1 COLLATE NOCASE AND id>?2 AND origin>=?3 AND blocked=0;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_text(
@@ -165,6 +168,7 @@ pub unsafe fn dc_block_contact(
) && (*contact).blocked != new_blocking
{
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE contacts SET blocked=? WHERE id=?;\x00" as *const u8
as *const libc::c_char,
@@ -177,7 +181,8 @@ pub unsafe fn dc_block_contact(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET blocked=? WHERE type=? AND id IN (SELECT chat_id FROM chats_contacts WHERE contact_id=?);\x00"
as *const u8 as
*const libc::c_char);
@@ -283,9 +288,9 @@ pub unsafe fn dc_contact_empty(mut contact: *mut dc_contact_t) {
/* contacts with at least this origin value are verified and known not to be spam */
/* contacts with at least this origin value start a new "normal" chat, defaults to off */
pub unsafe fn dc_contact_load_from_db(
mut contact: *mut dc_contact_t,
mut sql: &mut dc_sqlite3_t,
mut contact_id: uint32_t,
contact: *mut dc_contact_t,
sql: &mut dc_sqlite3_t,
contact_id: uint32_t,
) -> libc::c_int {
let mut current_block: u64;
let mut success: libc::c_int = 0i32;
@@ -296,6 +301,7 @@ pub unsafe fn dc_contact_load_from_db(
(*contact).id = contact_id;
(*contact).name = dc_stock_str((*contact).context, 2i32);
(*contact).addr = dc_sqlite3_get_config(
(*contact).context,
sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
@@ -303,7 +309,8 @@ pub unsafe fn dc_contact_load_from_db(
current_block = 5143058163439228106;
} else {
stmt =
dc_sqlite3_prepare(sql,
dc_sqlite3_prepare(
(*contact).context,sql,
b"SELECT c.name, c.addr, c.origin, c.blocked, c.authname FROM contacts c WHERE c.id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, contact_id as libc::c_int);
@@ -369,6 +376,7 @@ pub unsafe fn dc_add_or_lookup_contact(
if !(addr__.is_null() || origin <= 0i32) {
addr = dc_addr_normalize(addr__);
addr_self = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
@@ -389,7 +397,8 @@ pub unsafe fn dc_add_or_lookup_contact(
);
} else {
stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.clone().lock().unwrap(),
b"SELECT id, name, addr, origin, authname FROM contacts WHERE addr=? COLLATE NOCASE;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, addr as *const libc::c_char, -1i32, None);
@@ -426,6 +435,7 @@ pub unsafe fn dc_add_or_lookup_contact(
|| origin > row_origin
{
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE contacts SET name=?, addr=?, origin=?, authname=? WHERE id=?;\x00"
as *const u8 as *const libc::c_char,
@@ -470,7 +480,8 @@ pub unsafe fn dc_add_or_lookup_contact(
stmt = 0 as *mut sqlite3_stmt;
if 0 != update_name {
stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET name=? WHERE type=? AND id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?);\x00"
as *const u8 as
*const libc::c_char);
@@ -485,6 +496,7 @@ pub unsafe fn dc_add_or_lookup_contact(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO contacts (name, addr, origin) VALUES(?, ?, ?);\x00" as *const u8
as *const libc::c_char,
@@ -504,6 +516,7 @@ pub unsafe fn dc_add_or_lookup_contact(
sqlite3_bind_int(stmt, 3i32, origin);
if sqlite3_step(stmt) == 101i32 {
row_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.clone().lock().unwrap(),
b"contacts\x00" as *const u8 as *const libc::c_char,
b"addr\x00" as *const u8 as *const libc::c_char,
@@ -616,6 +629,7 @@ pub unsafe fn dc_get_contacts(
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
@@ -633,7 +647,8 @@ pub unsafe fn dc_get_contacts(
current_block = 7597307149762829253;
} else {
stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.clone().lock().unwrap(),
b"SELECT c.id FROM contacts c LEFT JOIN acpeerstates ps ON c.addr=ps.addr WHERE c.addr!=?1 AND c.id>?2 AND c.origin>=?3 AND c.blocked=0 AND (c.name LIKE ?4 OR c.addr LIKE ?5) AND (1=?6 OR LENGTH(ps.verified_key_fingerprint)!=0) ORDER BY LOWER(c.name||c.addr),c.id;\x00"
as *const u8 as
*const libc::c_char);
@@ -652,6 +667,7 @@ pub unsafe fn dc_get_contacts(
},
);
self_name = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"displayname\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
@@ -668,7 +684,8 @@ pub unsafe fn dc_get_contacts(
}
} else {
stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
dc_sqlite3_prepare(
context,&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM contacts WHERE addr!=?1 AND id>?2 AND origin>=?3 AND blocked=0 ORDER BY LOWER(name||addr),id;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, self_addr, -1i32, None);
@@ -702,6 +719,7 @@ pub unsafe fn dc_get_blocked_cnt(context: &dc_context_t) -> libc::c_int {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0\x00" as *const u8
as *const libc::c_char,
@@ -720,6 +738,7 @@ pub unsafe fn dc_get_blocked_contacts(mut context: &dc_context_t) -> *mut dc_arr
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM contacts WHERE id>? AND blocked!=0 ORDER BY LOWER(name||addr),id;\x00"
as *const u8 as *const libc::c_char,
@@ -771,11 +790,13 @@ pub unsafe fn dc_get_contact_encrinfo(
(*contact).addr,
);
dc_loginparam_read(
context,
loginparam,
&mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char,
);
dc_key_load_self_public(
context,
self_key,
(*loginparam).addr,
&mut context.sql.clone().lock().unwrap(),
@@ -794,6 +815,7 @@ pub unsafe fn dc_get_contact_encrinfo(
if (*self_key).binary.is_null() {
dc_ensure_secret_key_exists(context);
dc_key_load_self_public(
context,
self_key,
(*loginparam).addr,
&mut context.sql.clone().lock().unwrap(),
@@ -804,11 +826,11 @@ pub unsafe fn dc_get_contact_encrinfo(
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
dc_strbuilder_cat(&mut ret, b":\x00" as *const u8 as *const libc::c_char);
fingerprint_self = dc_key_get_formatted_fingerprint(self_key);
fingerprint_self = dc_key_get_formatted_fingerprint(context, self_key);
fingerprint_other_verified =
dc_key_get_formatted_fingerprint(dc_apeerstate_peek_key(peerstate, 2i32));
dc_key_get_formatted_fingerprint(context, dc_apeerstate_peek_key(peerstate, 2i32));
fingerprint_other_unverified =
dc_key_get_formatted_fingerprint(dc_apeerstate_peek_key(peerstate, 0i32));
dc_key_get_formatted_fingerprint(context, dc_apeerstate_peek_key(peerstate, 0i32));
if strcmp((*loginparam).addr, (*peerstate).addr) < 0i32 {
cat_fingerprint(
&mut ret,
@@ -900,6 +922,7 @@ pub unsafe fn dc_delete_contact(
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !contact_id <= 9i32 as libc::c_uint {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;\x00" as *const u8
as *const libc::c_char,
@@ -909,6 +932,7 @@ pub unsafe fn dc_delete_contact(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;\x00" as *const u8
as *const libc::c_char,
@@ -919,6 +943,7 @@ pub unsafe fn dc_delete_contact(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM contacts WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1042,11 +1067,11 @@ pub unsafe fn dc_contact_is_blocked(mut contact: *const dc_contact_t) -> libc::c
return (*contact).blocked;
}
pub unsafe fn dc_contact_is_verified(mut contact: *mut dc_contact_t) -> libc::c_int {
return dc_contact_is_verified_ex(contact, 0 as *const dc_apeerstate_t);
return dc_contact_is_verified_ex(contact, 0 as *mut dc_apeerstate_t);
}
pub unsafe fn dc_contact_is_verified_ex<'a>(
contact: *mut dc_contact_t<'a>,
peerstate: *const dc_apeerstate_t<'a>,
mut peerstate: *mut dc_apeerstate_t<'a>,
) -> libc::c_int {
let mut current_block: u64;
let mut contact_verified: libc::c_int = 0i32;
@@ -1108,6 +1133,7 @@ pub unsafe fn dc_addr_equals_self(
if !addr.is_null() {
normalized_addr = dc_addr_normalize(addr);
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -1155,6 +1181,7 @@ pub unsafe fn dc_get_real_contact_cnt(mut context: &dc_context_t) -> size_t {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !context.sql.clone().lock().unwrap().cobj.is_null() {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM contacts WHERE id>?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1203,6 +1230,7 @@ pub unsafe fn dc_real_contact_exists(
let mut ret: libc::c_int = 0i32;
if !(context.sql.clone().lock().unwrap().cobj.is_null() || contact_id <= 9i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM contacts WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1220,6 +1248,7 @@ pub unsafe fn dc_scaleup_contact_origin(
mut origin: libc::c_int,
) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE contacts SET origin=? WHERE id=? AND origin<?;\x00" as *const u8
as *const libc::c_char,

123
src/dc_context.rs
View File

@@ -1,6 +1,5 @@
use libc;
use std::sync::{Arc, Condvar, Mutex, RwLock};
use std::time::SystemTime;
use crate::constants::VERSION;
use crate::dc_array::*;
@@ -33,20 +32,38 @@ pub struct dc_context_t {
pub inbox: Arc<Mutex<dc_imap_t>>,
pub perform_inbox_jobs_needed: Arc<RwLock<i32>>,
pub probe_imap_network: Arc<RwLock<i32>>,
pub sentbox_thread: dc_jobthread_t,
pub mvbox_thread: dc_jobthread_t,
pub sentbox_thread: Arc<Mutex<dc_jobthread_t>>,
pub mvbox_thread: Arc<Mutex<dc_jobthread_t>>,
pub smtp: Arc<Mutex<dc_smtp_t>>,
pub smtp_state: Arc<(Mutex<SmtpState>, Condvar)>,
pub oauth2_critical: Arc<Mutex<()>>,
pub cb: dc_callback_t,
pub os_name: *mut libc::c_char,
pub cmdline_sel_chat_id: u32,
pub bob_expects: i32,
pub bobs_status: i32,
pub bobs_qr_scan: Arc<RwLock<*mut dc_lot_t>>,
pub last_smeared_timestamp: Arc<RwLock<Option<SystemTime>>>,
pub bob: Arc<RwLock<BobStatus>>,
pub last_smeared_timestamp: Arc<RwLock<time_t>>,
pub ongoing_running: i32,
pub shall_stop_ongoing: i32,
pub shall_stop_ongoing: Arc<RwLock<i32>>,
}
unsafe impl std::marker::Send for dc_context_t {}
unsafe impl std::marker::Sync for dc_context_t {}
#[derive(Debug)]
pub struct BobStatus {
pub expects: i32,
pub status: i32,
pub qr_scan: *mut dc_lot_t,
}
impl Default for BobStatus {
fn default() -> Self {
BobStatus {
expects: 0,
status: 0,
qr_scan: std::ptr::null_mut(),
}
}
}
#[derive(Default, Debug)]
@@ -93,19 +110,17 @@ pub fn dc_context_new(
})),
userdata,
cb,
os_name: dc_strdup_keep_null(os_name),
os_name: unsafe { dc_strdup_keep_null(os_name) },
ongoing_running: 0,
shall_stop_ongoing: 1,
shall_stop_ongoing: Arc::new(RwLock::new(1)),
sql: Arc::new(Mutex::new(dc_sqlite3_new())),
smtp: Arc::new(Mutex::new(dc_smtp_new())),
smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
oauth2_critical: Arc::new(Mutex::new(())),
bob_expects: 0,
bobs_status: 0,
bobs_qr_scan: Arc::new(RwLock::new(std::ptr::null_mut())),
last_smeared_timestamp: Arc::new(RwLock::new(None)),
bob: Arc::new(RwLock::new(Default::default())),
last_smeared_timestamp: Arc::new(RwLock::new(0 as time_t)),
cmdline_sel_chat_id: 0,
sentbox_thread: unsafe {
sentbox_thread: Arc::new(Mutex::new(unsafe {
dc_jobthread_init(
b"SENTBOX\x00" as *const u8 as *const libc::c_char,
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
@@ -116,8 +131,8 @@ pub fn dc_context_new(
Some(cb_receive_imf),
),
)
},
mvbox_thread: unsafe {
})),
mvbox_thread: Arc::new(Mutex::new(unsafe {
dc_jobthread_init(
b"MVBOX\x00" as *const u8 as *const libc::c_char,
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
@@ -128,7 +143,7 @@ pub fn dc_context_new(
Some(cb_receive_imf),
),
)
},
})),
probe_imap_network: Arc::new(RwLock::new(0)),
perform_inbox_jobs_needed: Arc::new(RwLock::new(0)),
}
@@ -231,7 +246,7 @@ unsafe fn cb_get_config(
key: *const libc::c_char,
def: *const libc::c_char,
) -> *mut libc::c_char {
dc_sqlite3_get_config(&mut context.sql.clone().lock().unwrap(), key, def)
dc_sqlite3_get_config(context, &mut context.sql.clone().lock().unwrap(), key, def)
}
pub unsafe fn dc_context_unref(context: &mut dc_context_t) {
@@ -241,17 +256,33 @@ pub unsafe fn dc_context_unref(context: &mut dc_context_t) {
dc_imap_unref(context, &mut context.inbox.clone().lock().unwrap());
dc_imap_unref(
context,
&mut context.sentbox_thread.imap.clone().lock().unwrap(),
&mut context
.sentbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
);
dc_imap_unref(
context,
&mut context.mvbox_thread.imap.clone().lock().unwrap(),
&mut context
.mvbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
);
dc_smtp_unref(&mut context.smtp.clone().lock().unwrap());
dc_sqlite3_unref(context, &mut context.sql.clone().lock().unwrap());
dc_jobthread_exit(&mut context.sentbox_thread);
dc_jobthread_exit(&mut context.mvbox_thread);
dc_jobthread_exit(&mut context.sentbox_thread.clone().lock().unwrap());
dc_jobthread_exit(&mut context.mvbox_thread.clone().lock().unwrap());
free(context.os_name as *mut libc::c_void);
}
@@ -260,11 +291,27 @@ pub unsafe fn dc_close(context: &mut dc_context_t) {
dc_imap_disconnect(context, &mut context.inbox.clone().lock().unwrap());
dc_imap_disconnect(
context,
&mut context.sentbox_thread.imap.clone().lock().unwrap(),
&mut context
.sentbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
);
dc_imap_disconnect(
context,
&mut context.mvbox_thread.imap.clone().lock().unwrap(),
&mut context
.mvbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
);
dc_smtp_disconnect(&mut context.smtp.clone().lock().unwrap());
@@ -471,6 +518,7 @@ pub unsafe fn dc_get_config(context: &dc_context_t, key: *const libc::c_char) ->
if strcmp(key, b"selfavatar\x00" as *const u8 as *const libc::c_char) == 0 {
let mut rel_path: *mut libc::c_char = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
key,
0 as *const libc::c_char,
@@ -481,6 +529,7 @@ pub unsafe fn dc_get_config(context: &dc_context_t, key: *const libc::c_char) ->
}
} else {
value = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
key,
0 as *const libc::c_char,
@@ -638,16 +687,19 @@ pub unsafe fn dc_get_info(context: &dc_context_t) -> *mut libc::c_char {
l = dc_loginparam_new();
l2 = dc_loginparam_new();
dc_loginparam_read(
context,
l,
&mut context.sql.clone().lock().unwrap(),
b"\x00" as *const u8 as *const libc::c_char,
);
dc_loginparam_read(
context,
l2,
&mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char,
);
displayname = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"displayname\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -657,26 +709,31 @@ pub unsafe fn dc_get_info(context: &dc_context_t) -> *mut libc::c_char {
deaddrop_msgs = dc_get_deaddrop_msg_cnt(context) as libc::c_int;
contacts = dc_get_real_contact_cnt(context) as libc::c_int;
is_configured = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured\x00" as *const u8 as *const libc::c_char,
0,
);
dbversion = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"dbversion\x00" as *const u8 as *const libc::c_char,
0,
);
e2ee_enabled = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1,
);
mdns_enabled = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1,
);
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM keypairs;\x00" as *const u8 as *const libc::c_char,
);
@@ -684,6 +741,7 @@ pub unsafe fn dc_get_info(context: &dc_context_t) -> *mut libc::c_char {
prv_key_cnt = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM acpeerstates;\x00" as *const u8 as *const libc::c_char,
);
@@ -691,47 +749,55 @@ pub unsafe fn dc_get_info(context: &dc_context_t) -> *mut libc::c_char {
pub_key_cnt = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
if 0 != dc_key_load_self_public(
context,
self_public,
(*l2).addr,
&mut context.sql.clone().lock().unwrap(),
) {
fingerprint_str = dc_key_get_fingerprint(self_public)
fingerprint_str = dc_key_get_fingerprint(context, self_public)
} else {
fingerprint_str = dc_strdup(b"<Not yet calculated>\x00" as *const u8 as *const libc::c_char)
}
l_readable_str = dc_loginparam_get_readable(l);
l2_readable_str = dc_loginparam_get_readable(l2);
inbox_watch = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"inbox_watch\x00" as *const u8 as *const libc::c_char,
1,
);
sentbox_watch = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1,
);
mvbox_watch = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1,
);
mvbox_move = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_move\x00" as *const u8 as *const libc::c_char,
1,
);
folders_configured = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0,
);
configured_sentbox_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
b"<unset>\x00" as *const u8 as *const libc::c_char,
);
configured_mvbox_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
b"<unset>\x00" as *const u8 as *const libc::c_char,
@@ -844,6 +910,7 @@ pub unsafe fn dc_get_fresh_msgs(context: &dc_context_t) -> *mut dc_array_t {
let mut stmt = 0 as *mut sqlite3_stmt;
if !ret.is_null() {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT m.id FROM msgs m LEFT JOIN contacts ct \
ON m.from_id=ct.id LEFT JOIN chats c ON m.chat_id=c.id WHERE m.state=? \
@@ -889,6 +956,7 @@ pub unsafe fn dc_search_msgs(
strLikeBeg = dc_mprintf(b"%s%%\x00" as *const u8 as *const libc::c_char, real_query);
if 0 != chat_id {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id WHERE m.chat_id=? \
AND m.hidden=0 \
@@ -901,6 +969,7 @@ pub unsafe fn dc_search_msgs(
} else {
let mut show_deaddrop = 0;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id \
LEFT JOIN chats c ON m.chat_id=c.id WHERE m.chat_id>9 AND m.hidden=0 \
@@ -958,6 +1027,7 @@ pub unsafe fn dc_is_sentbox(
folder_name: *const libc::c_char,
) -> libc::c_int {
let mut sentbox_name = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -976,6 +1046,7 @@ pub unsafe fn dc_is_sentbox(
pub unsafe fn dc_is_mvbox(context: &dc_context_t, folder_name: *const libc::c_char) -> libc::c_int {
let mut mvbox_name = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,

8
src/dc_e2ee.rs
View File

@@ -74,6 +74,7 @@ pub unsafe fn dc_e2ee_encrypt(
/* libEtPan's pgp_encrypt_mime() takes the parent as the new root. We just expect the root as being given to this function. */
(*autocryptheader).prefer_encrypt = 0i32;
if 0 != dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
@@ -81,6 +82,7 @@ pub unsafe fn dc_e2ee_encrypt(
(*autocryptheader).prefer_encrypt = 1i32
}
(*autocryptheader).addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -137,6 +139,7 @@ pub unsafe fn dc_e2ee_encrypt(
if 0 != do_encrypt {
dc_keyring_add(keyring, (*autocryptheader).public_key);
if 0 == dc_key_load_self_private(
context,
sign_key,
(*autocryptheader).addr,
&mut context.sql.clone().lock().unwrap(),
@@ -516,6 +519,7 @@ unsafe fn load_or_generate_self_public_key(
let mut key_creation_here: libc::c_int = 0i32;
if !public_key.is_null() {
if 0 == dc_key_load_self_public(
context,
public_key,
self_addr,
&mut context.sql.clone().lock().unwrap(),
@@ -574,6 +578,7 @@ unsafe fn load_or_generate_self_public_key(
current_block = 10496152961502316708;
} else if 0
== dc_key_save_self_keypair(
context,
public_key,
private_key,
self_addr,
@@ -699,6 +704,7 @@ pub unsafe fn dc_e2ee_decrypt(
}
/* load private key for decryption */
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -706,6 +712,7 @@ pub unsafe fn dc_e2ee_decrypt(
if !self_addr.is_null() {
if !(0
== dc_keyring_load_self_private_for_decrypting(
context,
private_keyring,
self_addr,
&mut context.sql.clone().lock().unwrap(),
@@ -1218,6 +1225,7 @@ pub unsafe fn dc_ensure_secret_key_exists(mut context: &dc_context_t) -> libc::c
let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
if !public_key.is_null() {
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,

3
src/dc_imap.rs
View File

@@ -1250,7 +1250,6 @@ unsafe fn fake_idle(context: &dc_context_t, imap: &mut dc_imap_t) {
}) as time_t;
// FIXME
// pthread_mutex_lock(&mut imap.watch_condmutex);
let mut r: libc::c_int = 0;
let mut wakeup_at: timespec = timespec {
tv_sec: 0,
tv_nsec: 0,
@@ -1746,7 +1745,7 @@ pub unsafe fn dc_imap_delete_msg(
imap: &mut dc_imap_t,
rfc724_mid: *const libc::c_char,
folder: *const libc::c_char,
server_uid: uint32_t,
mut server_uid: uint32_t,
) -> libc::c_int {
let mut success: libc::c_int = 0;
let mut r: libc::c_int = 0;

42
src/dc_imex.rs
View File

@@ -93,6 +93,7 @@ pub unsafe fn dc_imex_has_backup(
let mut sql = dc_sqlite3_new();
if 0 != dc_sqlite3_open(context, &mut sql, curr_pathNfilename, 0x1i32) {
let mut curr_backup_time: time_t = dc_sqlite3_get_config_int(
context,
&mut sql,
b"backup_time\x00" as *const u8 as *const libc::c_char,
0i32,
@@ -130,6 +131,7 @@ pub unsafe fn dc_check_password(
let mut success: libc::c_int = 0i32;
dc_loginparam_read(
context,
loginparam,
&mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char,
@@ -163,11 +165,11 @@ pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc:
setup_code = dc_create_setup_code(context);
if !setup_code.is_null() {
/* this may require a keypair to be created. this may take a second ... */
if !(0 != context.shall_stop_ongoing) {
if !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
setup_file_content = dc_render_setup_file(context, setup_code);
if !setup_file_content.is_null() {
/* encrypting may also take a while ... */
if !(0 != context.shall_stop_ongoing) {
if !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
setup_file_name = dc_get_fine_pathNfilename(
context,
b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
@@ -194,7 +196,7 @@ pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc:
);
dc_param_set_int((*msg).param, 'S' as i32, 6i32);
dc_param_set_int((*msg).param, 'u' as i32, 2i32);
if !(0 != context.shall_stop_ongoing) {
if !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
msg_id = dc_send_msg(context, chat_id, msg);
if !(msg_id == 0i32 as libc::c_uint) {
dc_msg_unref(msg);
@@ -206,7 +208,8 @@ pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc:
as *const libc::c_char,
);
loop {
if 0 != context.shall_stop_ongoing {
if 0 != *context.shall_stop_ongoing.clone().read().unwrap()
{
current_block = 6116957410927263949;
break;
}
@@ -265,16 +268,19 @@ pub unsafe extern "C" fn dc_render_setup_file(
/* create the payload */
if !(0 == dc_ensure_secret_key_exists(context)) {
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
dc_key_load_self_private(
context,
curr_private_key,
self_addr,
&mut context.sql.clone().lock().unwrap(),
);
let mut e2ee_enabled: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
@@ -492,6 +498,7 @@ unsafe fn set_self_key(
);
} else {
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM keypairs WHERE public_key=? OR private_key=?;\x00" as *const u8
as *const libc::c_char,
@@ -509,16 +516,19 @@ unsafe fn set_self_key(
stmt = 0 as *mut sqlite3_stmt;
if 0 != set_default {
dc_sqlite3_execute(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE keypairs SET is_default=0;\x00" as *const u8 as *const libc::c_char,
);
}
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if 0 == dc_key_save_self_keypair(
context,
public_key,
private_key,
self_addr,
@@ -538,6 +548,7 @@ unsafe fn set_self_key(
) == 0i32
{
dc_sqlite3_set_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
0i32,
@@ -548,6 +559,7 @@ unsafe fn set_self_key(
) == 0i32
{
dc_sqlite3_set_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
@@ -974,6 +986,7 @@ unsafe fn import_backup(
))
{
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM backup_blobs;\x00" as *const u8 as *const libc::c_char,
);
@@ -982,6 +995,7 @@ unsafe fn import_backup(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT file_name, file_content FROM backup_blobs ORDER BY id;\x00"
as *const u8 as *const libc::c_char,
@@ -991,7 +1005,7 @@ unsafe fn import_backup(
current_block = 10891380440665537214;
break;
}
if 0 != context.shall_stop_ongoing {
if 0 != *context.shall_stop_ongoing.clone().read().unwrap() {
current_block = 8648553629232744886;
break;
}
@@ -1050,6 +1064,7 @@ unsafe fn import_backup(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
dc_sqlite3_execute(
context,
&mut context.sql.clone().lock().unwrap(),
b"DROP TABLE backup_blobs;\x00" as *const u8 as *const libc::c_char,
);
@@ -1147,7 +1162,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
b"backup_blobs\x00" as *const u8 as *const libc::c_char,
) {
if 0 ==
dc_sqlite3_execute(&mut sql,
dc_sqlite3_execute(context, &mut sql,
b"CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);\x00"
as *const u8 as
*const libc::c_char) {
@@ -1196,17 +1211,20 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
current_block = 11487273724841241105;
} else {
stmt =
dc_sqlite3_prepare(&mut sql,
b"INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_prepare(
context,
&mut sql,
b"INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);\x00"
as *const u8 as
*const libc::c_char);
loop {
dir_entry = readdir(dir_handle);
if dir_entry.is_null() {
current_block = 2631791190359682872;
break;
}
if 0 != context.shall_stop_ongoing {
if 0 != *context.shall_stop_ongoing.clone().read().unwrap()
{
delete_dest_file = 1i32;
current_block = 11487273724841241105;
break;
@@ -1315,6 +1333,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
11487273724841241105 => {}
_ => {
dc_sqlite3_set_config_int(
context,
&mut sql,
b"backup_time\x00" as *const u8 as *const libc::c_char,
now as int32_t,
@@ -1504,6 +1523,7 @@ unsafe fn export_self_keys(
let mut public_key: *mut dc_key_t = dc_key_new();
let mut private_key: *mut dc_key_t = dc_key_new();
let stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, public_key, private_key, is_default FROM keypairs;\x00" as *const u8
as *const libc::c_char,

180
src/dc_job.rs
View File

@@ -65,7 +65,7 @@ pub unsafe fn dc_perform_imap_jobs(context: &dc_context_t) {
);
}
unsafe fn dc_job_perform(
mut context: &dc_context_t,
context: &dc_context_t,
mut thread: libc::c_int,
mut probe_network: libc::c_int,
) {
@@ -90,15 +90,19 @@ unsafe fn dc_job_perform(
if probe_network == 0i32 {
select_stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
b"SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries FROM jobs WHERE thread=? AND desired_timestamp<=? ORDER BY action DESC, added_timestamp;\x00"
as *const u8 as *const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries FROM jobs WHERE thread=? AND desired_timestamp<=? ORDER BY action DESC, added_timestamp;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64);
sqlite3_bind_int64(select_stmt, 2i32, time(0 as *mut time_t) as sqlite3_int64);
} else {
select_stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
b"SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries FROM jobs WHERE thread=? AND tries>0 ORDER BY desired_timestamp, action DESC;\x00"
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries FROM jobs WHERE thread=? AND tries>0 ORDER BY desired_timestamp, action DESC;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64);
}
@@ -129,8 +133,16 @@ unsafe fn dc_job_perform(
dc_job_kill_action(context, job.action);
sqlite3_finalize(select_stmt);
select_stmt = 0 as *mut sqlite3_stmt;
dc_jobthread_suspend(&mut context.sentbox_thread, 1i32);
dc_jobthread_suspend(&mut context.mvbox_thread, 1i32);
dc_jobthread_suspend(
context,
&mut context.sentbox_thread.clone().lock().unwrap(),
1,
);
dc_jobthread_suspend(
context,
&mut context.mvbox_thread.clone().lock().unwrap(),
1,
);
dc_suspend_smtp_thread(context, 1i32);
}
let mut tries: libc::c_int = 0i32;
@@ -178,8 +190,16 @@ unsafe fn dc_job_perform(
tries += 1
}
if 900i32 == job.action || 910i32 == job.action {
dc_jobthread_suspend(&mut context.sentbox_thread, 0i32);
dc_jobthread_suspend(&mut context.mvbox_thread, 0i32);
dc_jobthread_suspend(
context,
&mut context.sentbox_thread.clone().lock().unwrap(),
0,
);
dc_jobthread_suspend(
context,
&mut context.mvbox_thread.clone().lock().unwrap(),
0,
);
dc_suspend_smtp_thread(context, 0i32);
break;
} else if job.try_again == 2i32 {
@@ -248,6 +268,7 @@ unsafe fn dc_job_perform(
}
unsafe fn dc_job_delete(mut context: &dc_context_t, mut job: *const dc_job_t) {
let mut delete_stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM jobs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -272,6 +293,7 @@ unsafe fn get_backoff_time_offset(mut c_tries: libc::c_int) -> time_t {
}
unsafe fn dc_job_update(mut context: &dc_context_t, mut job: *const dc_job_t) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE jobs SET desired_timestamp=?, tries=?, param=? WHERE id=?;\x00" as *const u8
as *const libc::c_char,
@@ -306,12 +328,16 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(mut context: &dc_context_t, mut job:
if 0 == dc_smtp_is_connected(&context.smtp.clone().lock().unwrap()) {
let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new();
dc_loginparam_read(
context,
loginparam,
&mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char,
);
let mut connected: libc::c_int =
dc_smtp_connect(&mut context.smtp.clone().lock().unwrap(), loginparam);
let mut connected: libc::c_int = dc_smtp_connect(
context,
&mut context.smtp.clone().lock().unwrap(),
loginparam,
);
dc_loginparam_unref(loginparam);
if 0 == connected {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
@@ -371,6 +397,7 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(mut context: &dc_context_t, mut job:
_ => {
/* send message */
if 0 == dc_smtp_send_msg(
context,
&mut context.smtp.clone().lock().unwrap(),
recipients_list,
buf as *const libc::c_char,
@@ -401,6 +428,7 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(mut context: &dc_context_t, mut job:
if 0 != (*job).foreign_id {
dc_update_msg_state(context, (*job).foreign_id, 26i32);
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT chat_id FROM msgs WHERE id=?\x00" as *const u8
as *const libc::c_char,
@@ -468,6 +496,7 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(mut context: &dc_context_t, mut job: *mut dc
2473556513754201174 => {
if !(0 == dc_msg_load_from_db(msg, context, (*job).foreign_id)) {
if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32,
@@ -480,6 +509,7 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(mut context: &dc_context_t, mut job: *mut dc
);
}
dest_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -584,6 +614,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(
}
if 0 != dc_param_get_int((*job).param, 'M' as i32, 0i32) {
if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32,
@@ -596,6 +627,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(
);
}
dest_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -658,6 +690,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(
_ => {
if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
@@ -715,6 +748,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(
_ => {
if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
@@ -894,8 +928,10 @@ pub unsafe fn dc_job_add(
return;
}
stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO jobs (added_timestamp, thread, action, foreign_id, param, desired_timestamp) VALUES (?,?,?,?,?,?);\x00"
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO jobs (added_timestamp, thread, action, foreign_id, param, desired_timestamp) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(stmt, 1i32, timestamp as sqlite3_int64);
sqlite3_bind_int(stmt, 2i32, thread);
@@ -933,7 +969,7 @@ pub unsafe fn dc_interrupt_smtp_idle(mut context: &dc_context_t) {
);
let &(ref lock, ref cvar) = &*context.smtp_state.clone();
let state = lock.lock().unwrap();
let mut state = lock.lock().unwrap();
state.perform_jobs_needed = 1;
state.idle = true;
@@ -1015,6 +1051,7 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(mut context: &dc_context_t, mut jo
/* delete all pending jobs with the given action */
pub unsafe fn dc_job_kill_action(mut context: &dc_context_t, mut action: libc::c_int) {
let mut stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1029,6 +1066,7 @@ pub unsafe fn dc_perform_imap_fetch(mut context: &dc_context_t) {
return;
}
if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"inbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
@@ -1046,14 +1084,14 @@ pub unsafe fn dc_perform_imap_fetch(mut context: &dc_context_t) {
0i32,
b"INBOX-fetch started...\x00" as *const u8 as *const libc::c_char,
);
dc_imap_fetch(&mut context.inbox.clone().lock().unwrap());
dc_imap_fetch(context, &mut context.inbox.clone().lock().unwrap());
if 0 != context.inbox.clone().lock().unwrap().should_reconnect {
dc_log_info(
context,
0i32,
b"INBOX-fetch aborted, starting over...\x00" as *const u8 as *const libc::c_char,
);
dc_imap_fetch(&mut context.inbox.clone().lock().unwrap());
dc_imap_fetch(context, &mut context.inbox.clone().lock().unwrap());
}
dc_log_info(
context,
@@ -1062,74 +1100,99 @@ pub unsafe fn dc_perform_imap_fetch(mut context: &dc_context_t) {
clock().wrapping_sub(start) as libc::c_double * 1000.0f64 / 1000000i32 as libc::c_double,
);
}
pub unsafe fn dc_perform_imap_idle(mut context: &dc_context_t) {
pub unsafe fn dc_perform_imap_idle(context: &dc_context_t) {
connect_to_inbox(context);
let l = context.inboxidle_condmutex.lock().unwrap();
if 0 != context.perform_inbox_jobs_needed {
if 0 != *context.perform_inbox_jobs_needed.clone().read().unwrap() {
dc_log_info(
context,
0i32,
b"INBOX-IDLE will not be started because of waiting jobs.\x00" as *const u8
as *const libc::c_char,
);
drop(l);
return;
}
drop(l);
dc_log_info(
context,
0i32,
b"INBOX-IDLE started...\x00" as *const u8 as *const libc::c_char,
);
dc_imap_idle(&mut context.inbox.clone().lock().unwrap());
dc_imap_idle(context, &mut context.inbox.clone().lock().unwrap());
dc_log_info(
context,
0i32,
b"INBOX-IDLE ended.\x00" as *const u8 as *const libc::c_char,
);
}
pub unsafe fn dc_perform_mvbox_fetch(mut context: &dc_context_t) {
pub unsafe fn dc_perform_mvbox_fetch(context: &dc_context_t) {
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_fetch(&mut context.mvbox_thread, use_network);
dc_jobthread_fetch(
context,
&mut context.mvbox_thread.clone().lock().unwrap(),
use_network,
);
}
pub unsafe fn dc_perform_mvbox_idle(mut context: &dc_context_t) {
pub unsafe fn dc_perform_mvbox_idle(context: &dc_context_t) {
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_idle(&mut context.mvbox_thread, use_network);
dc_jobthread_idle(
context,
&mut context.mvbox_thread.clone().lock().unwrap(),
use_network,
);
}
pub unsafe fn dc_interrupt_mvbox_idle(mut context: &dc_context_t) {
dc_jobthread_interrupt_idle(&mut context.mvbox_thread);
pub unsafe fn dc_interrupt_mvbox_idle(context: &dc_context_t) {
dc_jobthread_interrupt_idle(context, &mut context.mvbox_thread.clone().lock().unwrap());
}
pub unsafe fn dc_perform_sentbox_fetch(mut context: &dc_context_t) {
pub unsafe fn dc_perform_sentbox_fetch(context: &dc_context_t) {
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_fetch(&mut context.sentbox_thread, use_network);
dc_jobthread_fetch(
context,
&mut context.sentbox_thread.clone().lock().unwrap(),
use_network,
);
}
pub unsafe fn dc_perform_sentbox_idle(mut context: &dc_context_t) {
pub unsafe fn dc_perform_sentbox_idle(context: &dc_context_t) {
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_idle(&mut context.sentbox_thread, use_network);
dc_jobthread_idle(
context,
&mut context.sentbox_thread.clone().lock().unwrap(),
use_network,
);
}
pub unsafe fn dc_interrupt_sentbox_idle(mut context: &dc_context_t) {
dc_jobthread_interrupt_idle(&mut context.sentbox_thread);
pub unsafe fn dc_interrupt_sentbox_idle(context: &dc_context_t) {
dc_jobthread_interrupt_idle(context, &mut context.sentbox_thread.clone().lock().unwrap());
}
pub unsafe fn dc_perform_smtp_jobs(mut context: &dc_context_t) {
pub unsafe fn dc_perform_smtp_jobs(context: &dc_context_t) {
let probe_smtp_network = {
let &(ref lock, _) = &*context.smtp_state.clone();
let state = lock.lock().unwrap();
let mut state = lock.lock().unwrap();
let probe_smtp_network = state.probe_network;
state.probe_network = 0;
@@ -1162,7 +1225,7 @@ pub unsafe fn dc_perform_smtp_jobs(mut context: &dc_context_t) {
{
let &(ref lock, _) = &*context.smtp_state.clone();
let state = lock.lock().unwrap();
let mut state = lock.lock().unwrap();
state.doing_jobs = 0;
}
@@ -1186,16 +1249,15 @@ pub unsafe fn dc_perform_smtp_idle(mut context: &dc_context_t) {
as *const libc::c_char,
);
} else {
let mut r = false;
// FIXME: correct time based on
// get_next_wakeup_time(context, 5000) + 1;
let dur = Duration::from_milis(5000).unwrap();
let dur = Duration::from_millis(5000);
loop {
let res = cvar.wait_timeout(state, dur);
let res = cvar.wait_timeout(state, dur).unwrap();
state = res.0;
if state.idle == true || res.1 {
if state.idle == true || res.1.timed_out() {
// We received the notification and the value has been updated, we can leave.
break;
}
@@ -1211,10 +1273,11 @@ pub unsafe fn dc_perform_smtp_idle(mut context: &dc_context_t) {
);
}
unsafe fn get_next_wakeup_time(mut context: &dc_context_t, mut thread: libc::c_int) -> time_t {
unsafe fn get_next_wakeup_time(context: &dc_context_t, thread: libc::c_int) -> time_t {
let mut wakeup_time: time_t = 0i32 as time_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;\x00" as *const u8
as *const libc::c_char,
@@ -1224,30 +1287,35 @@ unsafe fn get_next_wakeup_time(mut context: &dc_context_t, mut thread: libc::c_i
wakeup_time = sqlite3_column_int(stmt, 0i32) as time_t
}
if wakeup_time == 0i32 as libc::c_long {
wakeup_time = time(0 as &time_t) + (10i32 * 60i32) as libc::c_long
wakeup_time = time(0 as *mut time_t) + (10i32 * 60i32) as libc::c_long
}
sqlite3_finalize(stmt);
return wakeup_time;
}
pub unsafe fn dc_maybe_network(mut context: &dc_context_t) {
pthread_mutex_lock(&mut context.smtpidle_condmutex);
context.probe_smtp_network = 1i32;
pthread_mutex_unlock(&mut context.smtpidle_condmutex);
let l = context.inboxidle_condmutex.lock().unwrap();
context.probe_imap_network = 1i32;
drop(l);
{
let &(ref lock, _) = &*context.smtp_state.clone();
let mut state = lock.lock().unwrap();
state.probe_network = 1;
*context.probe_imap_network.clone().write().unwrap() = 1;
}
dc_interrupt_smtp_idle(context);
dc_interrupt_imap_idle(context);
dc_interrupt_mvbox_idle(context);
dc_interrupt_sentbox_idle(context);
}
pub unsafe fn dc_job_action_exists(
mut context: &dc_context_t,
mut action: libc::c_int,
) -> libc::c_int {
let mut job_exists: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1257,10 +1325,10 @@ pub unsafe fn dc_job_action_exists(
return job_exists;
}
/* special case for DC_JOB_SEND_MSG_TO_SMTP */
pub unsafe fn dc_job_send_msg(mut context: &dc_context_t, mut msg_id: uint32_t) -> libc::c_int {
pub unsafe fn dc_job_send_msg(context: &dc_context_t, msg_id: uint32_t) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut mimefactory: dc_mimefactory_t = dc_mimefactory_t {
from_addr: 0 as &libc::c_char,
let mut mimefactory = dc_mimefactory_t {
from_addr: 0 as *mut libc::c_char,
from_displayname: 0 as *mut libc::c_char,
selfstatus: 0 as *mut libc::c_char,
recipients_names: 0 as *mut clist,
@@ -1279,7 +1347,7 @@ pub unsafe fn dc_job_send_msg(mut context: &dc_context_t, mut msg_id: uint32_t)
out_gossiped: 0,
out_last_added_location_id: 0,
error: 0 as *mut libc::c_char,
context: std::ptr::null_mut(),
context,
};
dc_mimefactory_init(&mut mimefactory, context);
/* load message data */
@@ -1299,7 +1367,7 @@ pub unsafe fn dc_job_send_msg(mut context: &dc_context_t, mut msg_id: uint32_t)
|| (*mimefactory.msg).type_0 == 50i32
|| (*mimefactory.msg).type_0 == 60i32
{
let mut pathNfilename: &libc::c_char = dc_param_get(
let mut pathNfilename = dc_param_get(
(*mimefactory.msg).param,
'f' as i32,
0 as *const libc::c_char,

307
src/dc_jobthread.rs
View File

@@ -14,15 +14,10 @@ use crate::x::*;
#[repr(C)]
pub struct dc_jobthread_t {
// TODO: remove
pub context: *mut dc_context_t,
pub name: *mut libc::c_char,
pub folder_config_name: *mut libc::c_char,
pub imap: Arc<Mutex<dc_imap_t>>,
pub idle: (Mutex<bool>, Condvar),
pub jobs_needed: libc::c_int,
pub suspended: libc::c_int,
pub using_handle: libc::c_int,
pub state: Arc<(Mutex<JobState>, Condvar)>,
}
pub unsafe fn dc_jobthread_init(
@@ -31,219 +26,243 @@ pub unsafe fn dc_jobthread_init(
imap: dc_imap_t,
) -> dc_jobthread_t {
dc_jobthread_t {
context: std::ptr::null_mut(),
name: dc_strdup(name),
folder_config_name: dc_strdup(folder_config_name),
imap: Arc::new(Mutex::New(imap)),
idle: (Mutex::new(false), Condvar::new()),
jobs_needed: 0i32,
suspended: 0i32,
using_handle: 0i32,
imap: Arc::new(Mutex::new(imap)),
state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
}
}
pub unsafe fn dc_jobthread_exit(mut jobthread: *mut dc_jobthread_t) {
if jobthread.is_null() {
return;
}
free((*jobthread).name as *mut libc::c_void);
(*jobthread).name = 0 as *mut libc::c_char;
free((*jobthread).folder_config_name as *mut libc::c_void);
(*jobthread).folder_config_name = 0 as *mut libc::c_char;
#[derive(Debug, Default)]
pub struct JobState {
idle: bool,
jobs_needed: i32,
suspended: i32,
using_handle: i32,
}
pub unsafe fn dc_jobthread_suspend(mut jobthread: *mut dc_jobthread_t, mut suspend: libc::c_int) {
if jobthread.is_null() {
return;
}
pub unsafe fn dc_jobthread_exit(jobthread: &mut dc_jobthread_t) {
free(jobthread.name as *mut libc::c_void);
jobthread.name = 0 as *mut libc::c_char;
free(jobthread.folder_config_name as *mut libc::c_void);
jobthread.folder_config_name = 0 as *mut libc::c_char;
}
pub unsafe fn dc_jobthread_suspend(
context: &dc_context_t,
jobthread: &mut dc_jobthread_t,
suspend: libc::c_int,
) {
if 0 != suspend {
dc_log_info(
(*jobthread).context,
context,
0i32,
b"Suspending %s-thread.\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
);
pthread_mutex_lock(&mut (*jobthread).mutex);
(*jobthread).suspended = 1i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
dc_jobthread_interrupt_idle(jobthread);
{
jobthread.state.clone().0.lock().unwrap().suspended = 1;
}
dc_jobthread_interrupt_idle(context, jobthread);
loop {
pthread_mutex_lock(&mut (*jobthread).mutex);
if (*jobthread).using_handle == 0i32 {
pthread_mutex_unlock(&mut (*jobthread).mutex);
let using_handle = jobthread.state.clone().0.lock().unwrap().using_handle;
if using_handle == 0 {
return;
}
pthread_mutex_unlock(&mut (*jobthread).mutex);
usleep((300i32 * 1000i32) as useconds_t);
}
} else {
dc_log_info(
(*jobthread).context,
context,
0i32,
b"Unsuspending %s-thread.\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
);
pthread_mutex_lock(&mut (*jobthread).mutex);
(*jobthread).suspended = 0i32;
(*jobthread).idle_condflag = 1i32;
pthread_cond_signal(&mut (*jobthread).idle_cond);
pthread_mutex_unlock(&mut (*jobthread).mutex);
};
}
pub unsafe extern "C" fn dc_jobthread_interrupt_idle(mut jobthread: *mut dc_jobthread_t) {
if jobthread.is_null() {
return;
let &(ref lock, ref cvar) = &*jobthread.state.clone();
let mut state = lock.lock().unwrap();
state.suspended = 0;
state.idle = true;
cvar.notify_one();
}
pthread_mutex_lock(&mut (*jobthread).mutex);
(*jobthread).jobs_needed = 1i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
}
pub unsafe extern "C" fn dc_jobthread_interrupt_idle(
context: &dc_context_t,
jobthread: &mut dc_jobthread_t,
) {
{
jobthread.state.clone().0.lock().unwrap().jobs_needed = 1;
}
dc_log_info(
(*jobthread).context,
0i32,
context,
0,
b"Interrupting %s-IDLE...\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
);
if !(*jobthread).imap.is_null() {
dc_imap_interrupt_idle((*jobthread).imap);
}
pthread_mutex_lock(&mut (*jobthread).mutex);
(*jobthread).idle_condflag = 1i32;
pthread_cond_signal(&mut (*jobthread).idle_cond);
pthread_mutex_unlock(&mut (*jobthread).mutex);
dc_imap_interrupt_idle(&mut jobthread.imap.clone().lock().unwrap());
let &(ref lock, ref cvar) = &*jobthread.state.clone();
let mut state = lock.lock().unwrap();
state.idle = true;
cvar.notify_one();
}
pub unsafe fn dc_jobthread_fetch(mut jobthread: *mut dc_jobthread_t, mut use_network: libc::c_int) {
let mut start: libc::clock_t = 0;
if jobthread.is_null() {
return;
pub unsafe fn dc_jobthread_fetch(
context: &dc_context_t,
jobthread: &mut dc_jobthread_t,
use_network: libc::c_int,
) {
let mut start = 0;
{
let &(ref lock, _) = &*jobthread.state.clone();
let mut state = lock.lock().unwrap();
if 0 != state.suspended {
return;
}
state.using_handle = 1;
}
pthread_mutex_lock(&mut (*jobthread).mutex);
if 0 != (*jobthread).suspended {
pthread_mutex_unlock(&mut (*jobthread).mutex);
return;
}
(*jobthread).using_handle = 1i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
if !(0 == use_network || (*jobthread).imap.is_null()) {
if !0 == use_network {
start = clock();
if !(0 == connect_to_imap(jobthread)) {
if !(0 == connect_to_imap(context, jobthread)) {
dc_log_info(
(*jobthread).context,
0i32,
context,
0,
b"%s-fetch started...\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
);
dc_imap_fetch((*jobthread).imap);
if 0 != (*(*jobthread).imap).should_reconnect {
dc_imap_fetch(context, &mut jobthread.imap.clone().lock().unwrap());
if 0 != jobthread.imap.clone().lock().unwrap().should_reconnect {
dc_log_info(
(*jobthread).context,
context,
0i32,
b"%s-fetch aborted, starting over...\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
);
dc_imap_fetch((*jobthread).imap);
dc_imap_fetch(context, &mut jobthread.imap.clone().lock().unwrap());
}
dc_log_info(
(*jobthread).context,
0i32,
context,
0,
b"%s-fetch done in %.0f ms.\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
clock().wrapping_sub(start) as libc::c_double * 1000.0f64
/ 1000000i32 as libc::c_double,
);
}
}
pthread_mutex_lock(&mut (*jobthread).mutex);
(*jobthread).using_handle = 0i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
jobthread.state.clone().0.lock().unwrap().using_handle = 0;
}
/* ******************************************************************************
* the typical fetch, idle, interrupt-idle
******************************************************************************/
unsafe fn connect_to_imap(mut jobthread: *mut dc_jobthread_t) -> libc::c_int {
unsafe fn connect_to_imap(context: &dc_context_t, jobthread: &mut dc_jobthread_t) -> libc::c_int {
let mut ret_connected: libc::c_int = 0i32;
let mut mvbox_name: *mut libc::c_char = 0 as *mut libc::c_char;
if 0 != dc_imap_is_connected((*jobthread).imap) {
ret_connected = 1i32
if 0 != dc_imap_is_connected(&mut jobthread.imap.clone().lock().unwrap()) {
ret_connected = 1
} else {
ret_connected = dc_connect_to_configured_imap((*jobthread).context, (*jobthread).imap);
ret_connected =
dc_connect_to_configured_imap(context, &mut jobthread.imap.clone().lock().unwrap());
if !(0 == ret_connected) {
if dc_sqlite3_get_config_int(
(*(*jobthread).context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32,
) < 3i32
0,
) < 3
{
dc_configure_folders((*jobthread).context, (*jobthread).imap, 0x1i32);
dc_configure_folders(context, &mut jobthread.imap.clone().lock().unwrap(), 0x1);
}
mvbox_name = dc_sqlite3_get_config(
(*(*jobthread).context).sql,
(*jobthread).folder_config_name,
context,
&mut context.sql.clone().lock().unwrap(),
jobthread.folder_config_name,
0 as *const libc::c_char,
);
if mvbox_name.is_null() {
dc_imap_disconnect((*jobthread).imap);
ret_connected = 0i32
dc_imap_disconnect(context, &mut jobthread.imap.clone().lock().unwrap());
ret_connected = 0;
} else {
dc_imap_set_watch_folder((*jobthread).imap, mvbox_name);
dc_imap_set_watch_folder(&mut jobthread.imap.clone().lock().unwrap(), mvbox_name);
}
}
}
free(mvbox_name as *mut libc::c_void);
return ret_connected;
ret_connected
}
pub unsafe fn dc_jobthread_idle(mut jobthread: *mut dc_jobthread_t, mut use_network: libc::c_int) {
if jobthread.is_null() {
return;
}
pthread_mutex_lock(&mut (*jobthread).mutex);
if 0 != (*jobthread).jobs_needed {
dc_log_info(
(*jobthread).context,
0i32,
b"%s-IDLE will not be started as it was interrupted while not ideling.\x00" as *const u8
as *const libc::c_char,
(*jobthread).name,
);
(*jobthread).jobs_needed = 0i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
return;
}
if 0 != (*jobthread).suspended {
while (*jobthread).idle_condflag == 0i32 {
pthread_cond_wait(&mut (*jobthread).idle_cond, &mut (*jobthread).mutex);
pub unsafe fn dc_jobthread_idle(
context: &dc_context_t,
jobthread: &mut dc_jobthread_t,
use_network: libc::c_int,
) {
{
let &(ref lock, ref cvar) = &*jobthread.state.clone();
let mut state = lock.lock().unwrap();
if 0 != state.jobs_needed {
dc_log_info(
context,
0,
b"%s-IDLE will not be started as it was interrupted while not ideling.\x00"
as *const u8 as *const libc::c_char,
jobthread.name,
);
state.jobs_needed = 0;
return;
}
(*jobthread).idle_condflag = 0i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
return;
}
(*jobthread).using_handle = 1i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
if 0 == use_network || (*jobthread).imap.is_null() {
pthread_mutex_lock(&mut (*jobthread).mutex);
(*jobthread).using_handle = 0i32;
while (*jobthread).idle_condflag == 0i32 {
pthread_cond_wait(&mut (*jobthread).idle_cond, &mut (*jobthread).mutex);
if 0 != state.suspended {
while !state.idle {
state = cvar.wait(state).unwrap();
}
state.idle = false;
return;
}
state.using_handle = 1;
if 0 == use_network {
state.using_handle = 0;
while !state.idle {
state = cvar.wait(state).unwrap();
}
state.idle = false;
return;
}
(*jobthread).idle_condflag = 0i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
return;
}
connect_to_imap(jobthread);
connect_to_imap(context, jobthread);
dc_log_info(
(*jobthread).context,
context,
0i32,
b"%s-IDLE started...\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
);
dc_imap_idle((*jobthread).imap);
dc_imap_idle(context, &mut jobthread.imap.clone().lock().unwrap());
dc_log_info(
(*jobthread).context,
context,
0i32,
b"%s-IDLE ended.\x00" as *const u8 as *const libc::c_char,
(*jobthread).name,
jobthread.name,
);
pthread_mutex_lock(&mut (*jobthread).mutex);
(*jobthread).using_handle = 0i32;
pthread_mutex_unlock(&mut (*jobthread).mutex);
jobthread.state.clone().0.lock().unwrap().using_handle = 0;
}

56
src/dc_key.rs
View File

@@ -252,24 +252,26 @@ pub unsafe fn dc_key_equals(mut key: *const dc_key_t, mut o: *const dc_key_t) ->
}
}
pub unsafe fn dc_key_save_self_keypair(
mut public_key: *const dc_key_t,
mut private_key: *const dc_key_t,
mut addr: *const libc::c_char,
mut is_default: libc::c_int,
mut sql: &mut dc_sqlite3_t,
context: &dc_context_t,
public_key: *const dc_key_t,
private_key: *const dc_key_t,
addr: *const libc::c_char,
is_default: libc::c_int,
sql: &mut dc_sqlite3_t,
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(public_key.is_null()
|| private_key.is_null()
|| addr.is_null()
|| sql.is_null()
|| (*public_key).binary.is_null()
|| (*private_key).binary.is_null())
{
stmt =
dc_sqlite3_prepare(sql,
b"INSERT INTO keypairs (addr, is_default, public_key, private_key, created) VALUES (?,?,?,?,?);\x00"
dc_sqlite3_prepare(
context,
sql,
b"INSERT INTO keypairs (addr, is_default, public_key, private_key, created) VALUES (?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, addr, -1i32, None);
sqlite3_bind_int(stmt, 2i32, is_default);
@@ -290,15 +292,17 @@ pub unsafe fn dc_key_save_self_keypair(
return success;
}
pub unsafe fn dc_key_load_self_public(
mut key: *mut dc_key_t,
mut self_addr: *const libc::c_char,
mut sql: &mut dc_sqlite3_t,
context: &dc_context_t,
key: *mut dc_key_t,
self_addr: *const libc::c_char,
sql: &mut dc_sqlite3_t,
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(key.is_null() || self_addr.is_null() || sql.is_null()) {
if !(key.is_null() || self_addr.is_null()) {
dc_key_empty(key);
stmt = dc_sqlite3_prepare(
context,
sql,
b"SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8
as *const libc::c_char,
@@ -313,15 +317,17 @@ pub unsafe fn dc_key_load_self_public(
return success;
}
pub unsafe fn dc_key_load_self_private(
mut key: *mut dc_key_t,
mut self_addr: *const libc::c_char,
mut sql: &mut dc_sqlite3_t,
context: &dc_context_t,
key: *mut dc_key_t,
self_addr: *const libc::c_char,
sql: &mut dc_sqlite3_t,
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(key.is_null() || self_addr.is_null() || sql.is_null()) {
if !(key.is_null() || self_addr.is_null()) {
dc_key_empty(key);
stmt = dc_sqlite3_prepare(
context,
sql,
b"SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8
as *const libc::c_char,
@@ -469,7 +475,7 @@ pub unsafe fn dc_key_render_asc_to_file(
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut file_content: *mut libc::c_char = 0 as *mut libc::c_char;
if !(key.is_null() || file.is_null() || context.is_null()) {
if !(key.is_null() || file.is_null()) {
file_content = dc_key_render_asc(key, 0 as *const libc::c_char);
if !file_content.is_null() {
if 0 == dc_write_file(
@@ -546,12 +552,17 @@ pub unsafe fn dc_normalize_fingerprint(mut in_0: *const libc::c_char) -> *mut li
}
return out.buf;
}
pub unsafe fn dc_key_get_fingerprint(mut key: *const dc_key_t) -> *mut libc::c_char {
pub unsafe fn dc_key_get_fingerprint(
context: &dc_context_t,
key: *const dc_key_t,
) -> *mut libc::c_char {
let mut fingerprint_buf: *mut uint8_t = 0 as *mut uint8_t;
let mut fingerprint_bytes: size_t = 0i32 as size_t;
let mut fingerprint_hex: *mut libc::c_char = 0 as *mut libc::c_char;
if !key.is_null() {
if !(0 == dc_pgp_calc_fingerprint(key, &mut fingerprint_buf, &mut fingerprint_bytes)) {
if !(0
== dc_pgp_calc_fingerprint(context, key, &mut fingerprint_buf, &mut fingerprint_bytes))
{
fingerprint_hex = dc_binary_to_uc_hex(fingerprint_buf, fingerprint_bytes)
}
}
@@ -562,8 +573,11 @@ pub unsafe fn dc_key_get_fingerprint(mut key: *const dc_key_t) -> *mut libc::c_c
dc_strdup(0 as *const libc::c_char)
};
}
pub unsafe fn dc_key_get_formatted_fingerprint(mut key: *const dc_key_t) -> *mut libc::c_char {
let mut rawhex: *mut libc::c_char = dc_key_get_fingerprint(key);
pub unsafe fn dc_key_get_formatted_fingerprint(
context: &dc_context_t,
key: *const dc_key_t,
) -> *mut libc::c_char {
let mut rawhex: *mut libc::c_char = dc_key_get_fingerprint(context, key);
let mut formatted: *mut libc::c_char = dc_format_fingerprint(rawhex);
free(rawhex as *mut libc::c_void);
return formatted;

11
src/dc_keyring.rs
View File

@@ -1,5 +1,6 @@
use libc;
use crate::dc_context::dc_context_t;
use crate::dc_key::*;
use crate::dc_sqlite3::*;
use crate::types::*;
@@ -54,14 +55,16 @@ pub unsafe fn dc_keyring_add(mut keyring: *mut dc_keyring_t, mut to_add: *mut dc
(*keyring).count += 1;
}
pub unsafe fn dc_keyring_load_self_private_for_decrypting(
mut keyring: *mut dc_keyring_t,
mut self_addr: *const libc::c_char,
mut sql: &mut dc_sqlite3_t,
context: &dc_context_t,
keyring: *mut dc_keyring_t,
self_addr: *const libc::c_char,
sql: &mut dc_sqlite3_t,
) -> libc::c_int {
if keyring.is_null() || self_addr.is_null() || sql.is_null() {
if keyring.is_null() || self_addr.is_null() {
return 0i32;
}
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
sql,
b"SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;\x00" as *const u8
as *const libc::c_char,

416
src/dc_location.rs
View File

@@ -51,16 +51,14 @@ pub unsafe fn dc_send_locations_to_chat(
let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
let mut is_sending_locations_before: libc::c_int = 0i32;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| seconds < 0i32
|| chat_id <= 9i32 as libc::c_uint)
{
if !(seconds < 0i32 || chat_id <= 9i32 as libc::c_uint) {
is_sending_locations_before = dc_is_sending_locations_to_chat(context, chat_id);
stmt =
dc_sqlite3_prepare((*context).sql,
b"UPDATE chats SET locations_send_begin=?, locations_send_until=? WHERE id=?\x00"
as *const u8 as *const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET locations_send_begin=?, locations_send_until=? WHERE id=?\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(
stmt,
1i32,
@@ -102,7 +100,7 @@ pub unsafe fn dc_send_locations_to_chat(
);
dc_add_device_msg(context, chat_id, stock_str);
}
((*context).cb)(
(context.cb)(
context,
Event::CHAT_MODIFIED,
chat_id as uintptr_t,
@@ -137,27 +135,28 @@ pub unsafe extern "C" fn dc_is_sending_locations_to_chat(
) -> libc::c_int {
let mut is_sending_locations: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;\x00"
as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int64(stmt, 3i32, time(0 as *mut time_t) as sqlite3_int64);
if !(sqlite3_step(stmt) != 100i32) {
is_sending_locations = 1i32
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int64(stmt, 3i32, time(0 as *mut time_t) as sqlite3_int64);
if !(sqlite3_step(stmt) != 100i32) {
is_sending_locations = 1i32
}
sqlite3_finalize(stmt);
return is_sending_locations;
}
@@ -170,14 +169,12 @@ pub unsafe fn dc_set_location(
let mut stmt_chats: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut continue_streaming: libc::c_int = 0i32;
if context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| latitude == 0.0f64 && longitude == 0.0f64
{
if latitude == 0.0f64 && longitude == 0.0f64 {
continue_streaming = 1i32
} else {
stmt_chats = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM chats WHERE locations_send_until>?;\x00" as *const u8
as *const libc::c_char,
);
@@ -185,9 +182,11 @@ pub unsafe fn dc_set_location(
while sqlite3_step(stmt_chats) == 100i32 {
let mut chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
stmt_insert =
dc_sqlite3_prepare((*context).sql,
b"INSERT INTO locations (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO locations (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_double(stmt_insert, 1i32, latitude);
sqlite3_bind_double(stmt_insert, 2i32, longitude);
sqlite3_bind_double(stmt_insert, 3i32, accuracy);
@@ -198,7 +197,7 @@ pub unsafe fn dc_set_location(
continue_streaming = 1i32
}
if 0 != continue_streaming {
((*context).cb)(
(context.cb)(
context,
Event::LOCATION_CHANGED,
1i32 as uintptr_t,
@@ -218,70 +217,71 @@ pub unsafe fn dc_get_locations(
mut timestamp_from: time_t,
mut timestamp_to: time_t,
) -> *mut dc_array_t {
let mut ret: *mut dc_array_t = dc_array_new_typed(context, 1i32, 500i32 as size_t);
let mut ret: *mut dc_array_t = dc_array_new_typed(1i32, 500i32 as size_t);
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
if timestamp_to == 0i32 as libc::c_long {
timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long
}
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent \
if timestamp_to == 0i32 as libc::c_long {
timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent \
m.id, l.from_id, l.chat_id, m.txt \
FROM locations l LEFT JOIN msgs m ON l.id=m.location_id WHERE (? OR l.chat_id=?) \
AND (? OR l.from_id=?) \
AND (l.independent=1 OR (l.timestamp>=? AND l.timestamp<=?)) \
ORDER BY l.timestamp DESC, l.id DESC, m.id DESC;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int(
stmt,
3i32,
if contact_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 4i32, contact_id as libc::c_int);
sqlite3_bind_int(stmt, 5i32, timestamp_from as libc::c_int);
sqlite3_bind_int(stmt, 6i32, timestamp_to as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
let mut loc: *mut _dc_location =
calloc(1, ::std::mem::size_of::<_dc_location>()) as *mut _dc_location;
if loc.is_null() {
break;
}
(*loc).location_id = sqlite3_column_double(stmt, 0i32) as uint32_t;
(*loc).latitude = sqlite3_column_double(stmt, 1i32);
(*loc).longitude = sqlite3_column_double(stmt, 2i32);
(*loc).accuracy = sqlite3_column_double(stmt, 3i32);
(*loc).timestamp = sqlite3_column_int64(stmt, 4i32) as time_t;
(*loc).independent = sqlite3_column_int(stmt, 5i32) as uint32_t;
(*loc).msg_id = sqlite3_column_int(stmt, 6i32) as uint32_t;
(*loc).contact_id = sqlite3_column_int(stmt, 7i32) as uint32_t;
(*loc).chat_id = sqlite3_column_int(stmt, 8i32) as uint32_t;
if 0 != (*loc).msg_id {
let mut txt: *const libc::c_char =
sqlite3_column_text(stmt, 9i32) as *const libc::c_char;
if 0 != is_marker(txt) {
(*loc).marker = strdup(txt)
}
}
dc_array_add_ptr(ret, loc as *mut libc::c_void);
as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int(
stmt,
3i32,
if contact_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 4i32, contact_id as libc::c_int);
sqlite3_bind_int(stmt, 5i32, timestamp_from as libc::c_int);
sqlite3_bind_int(stmt, 6i32, timestamp_to as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
let mut loc: *mut _dc_location =
calloc(1, ::std::mem::size_of::<_dc_location>()) as *mut _dc_location;
if loc.is_null() {
break;
}
(*loc).location_id = sqlite3_column_double(stmt, 0i32) as uint32_t;
(*loc).latitude = sqlite3_column_double(stmt, 1i32);
(*loc).longitude = sqlite3_column_double(stmt, 2i32);
(*loc).accuracy = sqlite3_column_double(stmt, 3i32);
(*loc).timestamp = sqlite3_column_int64(stmt, 4i32) as time_t;
(*loc).independent = sqlite3_column_int(stmt, 5i32) as uint32_t;
(*loc).msg_id = sqlite3_column_int(stmt, 6i32) as uint32_t;
(*loc).contact_id = sqlite3_column_int(stmt, 7i32) as uint32_t;
(*loc).chat_id = sqlite3_column_int(stmt, 8i32) as uint32_t;
if 0 != (*loc).msg_id {
let mut txt: *const libc::c_char =
sqlite3_column_text(stmt, 9i32) as *const libc::c_char;
if 0 != is_marker(txt) {
(*loc).marker = strdup(txt)
}
}
dc_array_add_ptr(ret, loc as *mut libc::c_void);
}
sqlite3_finalize(stmt);
return ret;
}
@@ -296,19 +296,20 @@ unsafe fn is_marker(mut txt: *const libc::c_char) -> libc::c_int {
}
pub unsafe fn dc_delete_all_locations(mut context: &dc_context_t) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare(
(*context).sql,
b"DELETE FROM locations;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
((*context).cb)(
context,
Event::LOCATION_CHANGED,
0i32 as uintptr_t,
0i32 as uintptr_t,
);
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM locations;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
(context.cb)(
context,
Event::LOCATION_CHANGED,
0i32 as uintptr_t,
0i32 as uintptr_t,
);
sqlite3_finalize(stmt);
}
pub unsafe fn dc_get_location_kml(
@@ -331,30 +332,34 @@ pub unsafe fn dc_get_location_kml(
eos: 0 as *mut libc::c_char,
};
dc_strbuilder_init(&mut ret, 1000i32);
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
self_addr = dc_sqlite3_get_config(
(*context).sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
stmt =
dc_sqlite3_prepare((*context).sql,
b"SELECT locations_send_begin, locations_send_until, locations_last_sent FROM chats WHERE id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(stmt) != 100i32) {
locations_send_begin = sqlite3_column_int64(stmt, 0i32) as time_t;
locations_send_until = sqlite3_column_int64(stmt, 1i32) as time_t;
locations_last_sent = sqlite3_column_int64(stmt, 2i32) as time_t;
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
if !(locations_send_begin == 0i32 as libc::c_long || now > locations_send_until) {
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
stmt =
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT locations_send_begin, locations_send_until, locations_last_sent FROM chats WHERE id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(stmt) != 100i32) {
locations_send_begin = sqlite3_column_int64(stmt, 0i32) as time_t;
locations_send_until = sqlite3_column_int64(stmt, 1i32) as time_t;
locations_last_sent = sqlite3_column_int64(stmt, 2i32) as time_t;
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
if !(locations_send_begin == 0i32 as libc::c_long || now > locations_send_until) {
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
b"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"%s\">\n\x00"
as *const u8 as *const libc::c_char,
self_addr);
stmt = dc_sqlite3_prepare(
(*context).sql,
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, latitude, longitude, accuracy, timestamp\
FROM locations WHERE from_id=? \
AND timestamp>=? \
@@ -365,44 +370,41 @@ pub unsafe fn dc_get_location_kml(
as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, 1i32);
sqlite3_bind_int64(stmt, 2i32, locations_send_begin as sqlite3_int64);
sqlite3_bind_int64(stmt, 3i32, locations_last_sent as sqlite3_int64);
sqlite3_bind_int(stmt, 4i32, 1i32);
while sqlite3_step(stmt) == 100i32 {
let mut location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let mut latitude: *mut libc::c_char =
dc_ftoa(sqlite3_column_double(stmt, 1i32));
let mut longitude: *mut libc::c_char =
dc_ftoa(sqlite3_column_double(stmt, 2i32));
let mut accuracy: *mut libc::c_char =
dc_ftoa(sqlite3_column_double(stmt, 3i32));
let mut timestamp: *mut libc::c_char =
get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as time_t);
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
sqlite3_bind_int(stmt, 1i32, 1i32);
sqlite3_bind_int64(stmt, 2i32, locations_send_begin as sqlite3_int64);
sqlite3_bind_int64(stmt, 3i32, locations_last_sent as sqlite3_int64);
sqlite3_bind_int(stmt, 4i32, 1i32);
while sqlite3_step(stmt) == 100i32 {
let mut location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let mut latitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 1i32));
let mut longitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 2i32));
let mut accuracy: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 3i32));
let mut timestamp: *mut libc::c_char =
get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as time_t);
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
b"<Placemark><Timestamp><when>%s</when></Timestamp><Point><coordinates accuracy=\"%s\">%s,%s</coordinates></Point></Placemark>\n\x00"
as *const u8 as
*const libc::c_char, timestamp,
accuracy, longitude, latitude);
location_count += 1;
if !last_added_location_id.is_null() {
*last_added_location_id = location_id
}
free(latitude as *mut libc::c_void);
free(longitude as *mut libc::c_void);
free(accuracy as *mut libc::c_void);
free(timestamp as *mut libc::c_void);
}
if !(location_count == 0i32) {
dc_strbuilder_cat(
&mut ret,
b"</Document>\n</kml>\x00" as *const u8 as *const libc::c_char,
);
success = 1i32
location_count += 1;
if !last_added_location_id.is_null() {
*last_added_location_id = location_id
}
free(latitude as *mut libc::c_void);
free(longitude as *mut libc::c_void);
free(accuracy as *mut libc::c_void);
free(timestamp as *mut libc::c_void);
}
if !(location_count == 0i32) {
dc_strbuilder_cat(
&mut ret,
b"</Document>\n</kml>\x00" as *const u8 as *const libc::c_char,
);
success = 1i32
}
}
}
sqlite3_finalize(stmt);
free(self_addr as *mut libc::c_void);
if 0 == success {
@@ -449,15 +451,10 @@ unsafe fn get_kml_timestamp(mut utc: time_t) -> *mut libc::c_char {
}
pub unsafe fn dc_get_message_kml(
context: &dc_context_t,
timestamp: time_t,
latitude: libc::c_double,
longitude: libc::c_double,
) -> *mut libc::c_char {
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
return std::ptr::null_mut();
}
let timestamp_str = get_kml_timestamp(timestamp);
let latitude_str = dc_ftoa(latitude);
let longitude_str = dc_ftoa(longitude);
@@ -485,13 +482,14 @@ pub unsafe fn dc_get_message_kml(
}
pub unsafe fn dc_set_kml_sent_timestamp(
mut context: &dc_context_t,
mut chat_id: uint32_t,
mut timestamp: time_t,
context: &dc_context_t,
chat_id: uint32_t,
timestamp: time_t,
) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET locations_last_sent=? WHERE id=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -507,7 +505,8 @@ pub unsafe fn dc_set_msg_location_id(
) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET location_id=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int64(stmt, 1i32, location_id as sqlite3_int64);
@@ -526,18 +525,16 @@ pub unsafe fn dc_save_locations(
let mut stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut newest_timestamp: time_t = 0i32 as time_t;
let mut newest_location_id: uint32_t = 0i32 as uint32_t;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| chat_id <= 9i32 as libc::c_uint
|| locations.is_null())
{
if !(chat_id <= 9i32 as libc::c_uint || locations.is_null()) {
stmt_test = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM locations WHERE timestamp=? AND from_id=?\x00" as *const u8
as *const libc::c_char,
);
stmt_insert = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO locations\
(timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
VALUES (?,?,?,?,?,?,?);\x00" as *const u8 as *const libc::c_char,
@@ -563,7 +560,8 @@ pub unsafe fn dc_save_locations(
if (*location).timestamp > newest_timestamp {
newest_timestamp = (*location).timestamp;
newest_location_id = dc_sqlite3_get_rowid2(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"locations\x00" as *const u8 as *const libc::c_char,
b"timestamp\x00" as *const u8 as *const libc::c_char,
(*location).timestamp as uint64_t,
@@ -591,33 +589,34 @@ pub unsafe fn dc_kml_parse(
text_cb: None,
userdata: 0 as *mut libc::c_void,
};
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
if content_bytes > (1 * 1024 * 1024) {
dc_log_warning(
context,
0,
b"A kml-files with %i bytes is larger than reasonably expected.\x00" as *const u8
as *const libc::c_char,
content_bytes,
if content_bytes > (1 * 1024 * 1024) {
dc_log_warning(
context,
0,
b"A kml-files with %i bytes is larger than reasonably expected.\x00" as *const u8
as *const libc::c_char,
content_bytes,
);
} else {
content_nullterminated = dc_null_terminate(content, content_bytes as libc::c_int);
if !content_nullterminated.is_null() {
(*kml).locations = dc_array_new_typed(1, 100 as size_t);
dc_saxparser_init(&mut saxparser, kml as *mut libc::c_void);
dc_saxparser_set_tag_handler(
&mut saxparser,
Some(kml_starttag_cb),
Some(kml_endtag_cb),
);
} else {
content_nullterminated = dc_null_terminate(content, content_bytes as libc::c_int);
if !content_nullterminated.is_null() {
(*kml).locations = dc_array_new_typed(context, 1, 100 as size_t);
dc_saxparser_init(&mut saxparser, kml as *mut libc::c_void);
dc_saxparser_set_tag_handler(
&mut saxparser,
Some(kml_starttag_cb),
Some(kml_endtag_cb),
);
dc_saxparser_set_text_handler(&mut saxparser, Some(kml_text_cb));
dc_saxparser_parse(&mut saxparser, content_nullterminated);
}
dc_saxparser_set_text_handler(&mut saxparser, Some(kml_text_cb));
dc_saxparser_parse(&mut saxparser, content_nullterminated);
}
}
free(content_nullterminated as *mut libc::c_void);
return kml;
}
unsafe fn kml_text_cb(userdata: *mut libc::c_void, text: *const libc::c_char, _len: libc::c_int) {
let mut kml: *mut dc_kml_t = userdata as *mut dc_kml_t;
if 0 != (*kml).tag & (0x4 | 0x10) {
@@ -774,7 +773,8 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
as *const libc::c_char,
);
stmt_chats = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, locations_send_begin, locations_last_sent\
FROM chats\
WHERE locations_send_until>?;\x00" as *const u8 as *const libc::c_char,
@@ -791,7 +791,8 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
}
if stmt_locations.is_null() {
stmt_locations = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id \
FROM locations \
WHERE from_id=? \
@@ -842,10 +843,11 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
let mut chat_id: uint32_t = (*job).foreign_id;
let mut locations_send_begin: time_t = 0i32 as time_t;
let mut locations_send_until: time_t = 0i32 as time_t;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut stmt = 0 as *mut sqlite3_stmt;
let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT locations_send_begin, locations_send_until FROM chats WHERE id=?\x00"
as *const u8 as *const libc::c_char,
);
@@ -866,10 +868,12 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
{
// not streaming, device-message already sent
stmt =
dc_sqlite3_prepare((*context).sql,
b"UPDATE chats SET locations_send_begin=0, locations_send_until=0 WHERE id=?\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET locations_send_begin=0, locations_send_until=0 WHERE id=?\x00"
as *const u8 as
*const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
sqlite3_step(stmt);
stock_str = dc_stock_system_msg(
@@ -880,7 +884,7 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
0i32 as uint32_t,
);
dc_add_device_msg(context, chat_id, stock_str);
((*context).cb)(
(context.cb)(
context,
Event::CHAT_MODIFIED,
chat_id as uintptr_t,

8
src/dc_log.rs
View File

@@ -30,9 +30,6 @@ unsafe fn log_vprintf(
mut va_0: ::std::ffi::VaList,
) {
let mut msg: *mut libc::c_char = 0 as *mut libc::c_char;
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return;
}
if !msg_format.is_null() {
let mut tempbuf: [libc::c_char; 1025] = [0; 1025];
vsnprintf(
@@ -58,10 +55,7 @@ pub unsafe extern "C" fn dc_log_event_seq(
mut msg: *const libc::c_char,
mut va_0: ...
) {
if context.is_null()
|| sequence_start.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
{
if sequence_start.is_null() {
return;
}
log_vprintf(context, event_code, *sequence_start, msg, va_0);

55
src/dc_loginparam.rs
View File

@@ -1,5 +1,6 @@
use libc;
use crate::dc_context::dc_context_t;
use crate::dc_sqlite3::*;
use crate::dc_strbuilder::*;
use crate::dc_tools::*;
@@ -60,9 +61,10 @@ pub unsafe fn dc_loginparam_empty(mut loginparam: *mut dc_loginparam_t) {
(*loginparam).server_flags = 0i32;
}
pub unsafe fn dc_loginparam_read(
mut loginparam: *mut dc_loginparam_t,
mut sql: &mut dc_sqlite3_t,
mut prefix: *const libc::c_char,
context: &dc_context_t,
loginparam: *mut dc_loginparam_t,
sql: &mut dc_sqlite3_t,
prefix: *const libc::c_char,
) {
let mut key: *mut libc::c_char = 0 as *mut libc::c_char;
dc_loginparam_empty(loginparam);
@@ -72,76 +74,77 @@ pub unsafe fn dc_loginparam_read(
prefix,
b"addr\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).addr = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
(*loginparam).addr = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_server\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_server = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
(*loginparam).mail_server = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_port\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_port = dc_sqlite3_get_config_int(sql, key, 0i32);
(*loginparam).mail_port = dc_sqlite3_get_config_int(context, sql, key, 0i32);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_user\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_user = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
(*loginparam).mail_user = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_pw\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_pw = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
(*loginparam).mail_pw = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_server\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_server = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
(*loginparam).send_server = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_port\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_port = dc_sqlite3_get_config_int(sql, key, 0i32);
(*loginparam).send_port = dc_sqlite3_get_config_int(context, sql, key, 0i32);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_user\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_user = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
(*loginparam).send_user = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_pw\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_pw = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
(*loginparam).send_pw = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"server_flags\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).server_flags = dc_sqlite3_get_config_int(sql, key, 0i32);
(*loginparam).server_flags = dc_sqlite3_get_config_int(context, sql, key, 0i32);
sqlite3_free(key as *mut libc::c_void);
}
pub unsafe fn dc_loginparam_write(
mut loginparam: *const dc_loginparam_t,
mut sql: &mut dc_sqlite3_t,
mut prefix: *const libc::c_char,
context: &dc_context_t,
loginparam: *const dc_loginparam_t,
sql: &mut dc_sqlite3_t,
prefix: *const libc::c_char,
) {
let mut key: *mut libc::c_char = 0 as *mut libc::c_char;
sqlite3_free(key as *mut libc::c_void);
@@ -150,70 +153,70 @@ pub unsafe fn dc_loginparam_write(
prefix,
b"addr\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(sql, key, (*loginparam).addr);
dc_sqlite3_set_config(context, sql, key, (*loginparam).addr);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_server\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(sql, key, (*loginparam).mail_server);
dc_sqlite3_set_config(context, sql, key, (*loginparam).mail_server);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_port\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config_int(sql, key, (*loginparam).mail_port);
dc_sqlite3_set_config_int(context, sql, key, (*loginparam).mail_port);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_user\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(sql, key, (*loginparam).mail_user);
dc_sqlite3_set_config(context, sql, key, (*loginparam).mail_user);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_pw\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(sql, key, (*loginparam).mail_pw);
dc_sqlite3_set_config(context, sql, key, (*loginparam).mail_pw);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_server\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(sql, key, (*loginparam).send_server);
dc_sqlite3_set_config(context, sql, key, (*loginparam).send_server);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_port\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config_int(sql, key, (*loginparam).send_port);
dc_sqlite3_set_config_int(context, sql, key, (*loginparam).send_port);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_user\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(sql, key, (*loginparam).send_user);
dc_sqlite3_set_config(context, sql, key, (*loginparam).send_user);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_pw\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(sql, key, (*loginparam).send_pw);
dc_sqlite3_set_config(context, sql, key, (*loginparam).send_pw);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"server_flags\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config_int(sql, key, (*loginparam).server_flags);
dc_sqlite3_set_config_int(context, sql, key, (*loginparam).server_flags);
sqlite3_free(key as *mut libc::c_void);
}
pub unsafe fn dc_loginparam_get_readable(

60
src/dc_mimefactory.rs
View File

@@ -51,7 +51,7 @@ pub unsafe fn dc_mimefactory_init<'a>(
factory: *mut dc_mimefactory_t<'a>,
context: &'a dc_context_t,
) {
if factory.is_null() || context.is_null() {
if factory.is_null() {
return;
}
memset(
@@ -105,16 +105,11 @@ pub unsafe fn dc_mimefactory_load_msg(
mut factory: *mut dc_mimefactory_t,
mut msg_id: uint32_t,
) -> libc::c_int {
let mut context: *mut dc_context_t = 0 as *mut dc_context_t;
let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(factory.is_null()
|| msg_id <= 9i32 as libc::c_uint
|| (*factory).context.is_null()
|| !(*factory).msg.is_null())
{
if !(factory.is_null() || msg_id <= 9i32 as libc::c_uint || !(*factory).msg.is_null()) {
/*call empty() before */
context = (*factory).context;
let context = (*factory).context;
(*factory).recipients_names = clist_new();
(*factory).recipients_addr = clist_new();
(*factory).msg = dc_msg_new_untyped(context);
@@ -128,7 +123,7 @@ pub unsafe fn dc_mimefactory_load_msg(
clist_insert_after(
(*factory).recipients_names,
(*(*factory).recipients_names).last,
dc_strdup_keep_null((*factory).from_displayname) as &libc::c_void,
dc_strdup_keep_null((*factory).from_displayname) as *mut libc::c_void,
);
clist_insert_after(
(*factory).recipients_addr,
@@ -137,10 +132,12 @@ pub unsafe fn dc_mimefactory_load_msg(
);
} else {
stmt =
dc_sqlite3_prepare((*context).sql,
b"SELECT c.authname, c.addr FROM chats_contacts cc LEFT JOIN contacts c ON cc.contact_id=c.id WHERE cc.chat_id=? AND cc.contact_id>9;\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT c.authname, c.addr FROM chats_contacts cc LEFT JOIN contacts c ON cc.contact_id=c.id WHERE cc.chat_id=? AND cc.contact_id>9;\x00"
as *const u8 as
*const libc::c_char);
sqlite3_bind_int(stmt, 1i32, (*(*factory).msg).chat_id as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
let mut authname: *const libc::c_char =
@@ -176,7 +173,8 @@ pub unsafe fn dc_mimefactory_load_msg(
0 as *const libc::c_char,
);
let mut self_addr: *mut libc::c_char = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
@@ -202,7 +200,8 @@ pub unsafe fn dc_mimefactory_load_msg(
if command != 6i32
&& command != 7i32
&& 0 != dc_sqlite3_get_config_int(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
)
@@ -211,7 +210,8 @@ pub unsafe fn dc_mimefactory_load_msg(
}
}
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?\x00" as *const u8
as *const libc::c_char,
);
@@ -238,17 +238,20 @@ pub unsafe fn dc_mimefactory_load_msg(
}
unsafe fn load_from(mut factory: *mut dc_mimefactory_t) {
(*factory).from_addr = dc_sqlite3_get_config(
(*(*factory).context).sql,
(*factory).context,
&mut (*factory).context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
(*factory).from_displayname = dc_sqlite3_get_config(
(*(*factory).context).sql,
(*factory).context,
&mut (*factory).context.sql.clone().lock().unwrap(),
b"displayname\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
(*factory).selfstatus = dc_sqlite3_get_config(
(*(*factory).context).sql,
(*factory).context,
&mut (*factory).context.sql.clone().lock().unwrap(),
b"selfstatus\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
@@ -268,7 +271,8 @@ pub unsafe fn dc_mimefactory_load_mdn(
(*factory).msg = dc_msg_new_untyped((*factory).context);
if !(0
== dc_sqlite3_get_config_int(
(*(*factory).context).sql,
(*factory).context,
&mut (*factory).context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
))
@@ -278,7 +282,7 @@ pub unsafe fn dc_mimefactory_load_mdn(
if !(0 == dc_msg_load_from_db((*factory).msg, (*factory).context, msg_id)
|| 0 == dc_contact_load_from_db(
contact,
(*(*factory).context).sql,
&mut (*factory).context.sql.clone().lock().unwrap(),
(*(*factory).msg).from_id,
))
{
@@ -858,12 +862,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
DC_PARAM_SET_LONGITUDE as libc::c_int,
0.0,
);
let kml_file = dc_get_message_kml(
(*msg).context,
(*msg).timestamp_sort,
latitude,
longitude,
);
let kml_file =
dc_get_message_kml((*msg).timestamp_sort, latitude, longitude);
if !kml_file.is_null() {
let content_type = mailmime_content_new_with_str(
b"application/vnd.google-earth.kml+xml\x00" as *const u8
@@ -1057,11 +1057,7 @@ unsafe fn get_subject(
mut msg: *const dc_msg_t,
mut afwd_email: libc::c_int,
) -> *mut libc::c_char {
let mut context: *mut dc_context_t = if !chat.is_null() {
(*chat).context
} else {
std::ptr::null_mut()
};
let context = (*chat).context;
let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
let mut raw_subject: *mut libc::c_char =
dc_msg_get_summarytext_by_raw((*msg).type_0, (*msg).text, (*msg).param, 32i32, context);

8
src/dc_mimeparser.rs
View File

@@ -35,7 +35,7 @@ pub struct dc_mimepart_t {
*/
#[derive(Copy, Clone)]
#[repr(C)]
pub struct dc_mimeparser_t {
pub struct dc_mimeparser_t<'a> {
pub parts: *mut carray,
pub mimeroot: *mut mailmime,
pub header: dc_hash_t,
@@ -47,7 +47,7 @@ pub struct dc_mimeparser_t {
pub e2ee_helper: *mut dc_e2ee_helper_t,
pub blobdir: *const libc::c_char,
pub is_forwarded: libc::c_int,
pub context: *mut dc_context_t,
pub context: &'a dc_context_t,
pub reports: *mut carray,
pub is_system_message: libc::c_int,
pub location_kml: *mut dc_kml_t,
@@ -61,8 +61,8 @@ pub unsafe fn dc_no_compound_msgs() {
// deprecated: flag to switch generation of compound messages on and off.
static mut s_generate_compound_msgs: libc::c_int = 1i32;
pub unsafe fn dc_mimeparser_new(
mut blobdir: *const libc::c_char,
mut context: &dc_context_t,
blobdir: *const libc::c_char,
context: &dc_context_t,
) -> *mut dc_mimeparser_t {
let mut mimeparser: *mut dc_mimeparser_t = 0 as *mut dc_mimeparser_t;
mimeparser = calloc(1, ::std::mem::size_of::<dc_mimeparser_t>()) as *mut dc_mimeparser_t;

3
src/dc_move.rs
View File

@@ -15,7 +15,8 @@ pub unsafe fn dc_do_heuristics_moves(
let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(dc_sqlite3_get_config_int(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_move\x00" as *const u8 as *const libc::c_char,
1i32,
) == 0i32)

587
src/dc_msg.rs
View File

@@ -67,225 +67,224 @@ pub unsafe fn dc_get_msg_info(
eos: 0 as *mut libc::c_char,
};
dc_strbuilder_init(&mut ret, 0i32);
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
dc_msg_load_from_db(msg, context, msg_id);
dc_contact_load_from_db(contact_from, (*context).sql, (*msg).from_id);
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT txt_raw FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
dc_msg_load_from_db(msg, context, msg_id);
dc_contact_load_from_db(
contact_from,
&mut context.sql.clone().lock().unwrap(),
(*msg).from_id,
);
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT txt_raw FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
if sqlite3_step(stmt) != 100i32 {
p = dc_mprintf(
b"Cannot load message #%i.\x00" as *const u8 as *const libc::c_char,
msg_id as libc::c_int,
);
sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
if sqlite3_step(stmt) != 100i32 {
p = dc_mprintf(
b"Cannot load message #%i.\x00" as *const u8 as *const libc::c_char,
msg_id as libc::c_int,
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
} else {
rawtxt = dc_strdup(sqlite3_column_text(stmt, 0i32) as *mut libc::c_char);
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
dc_trim(rawtxt);
dc_truncate_str(rawtxt, 100000i32);
dc_strbuilder_cat(&mut ret, b"Sent: \x00" as *const u8 as *const libc::c_char);
p = dc_timestamp_to_str(dc_msg_get_timestamp(msg));
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
p = dc_contact_get_name_n_addr(contact_from);
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b" by %s\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
if (*msg).from_id != 1i32 as libc::c_uint {
dc_strbuilder_cat(
&mut ret,
b"Received: \x00" as *const u8 as *const libc::c_char,
);
p = dc_timestamp_to_str(if 0 != (*msg).timestamp_rcvd {
(*msg).timestamp_rcvd
} else {
(*msg).timestamp_sort
});
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
} else {
rawtxt = dc_strdup(sqlite3_column_text(stmt, 0i32) as *mut libc::c_char);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
}
if !((*msg).from_id == 2i32 as libc::c_uint || (*msg).to_id == 2i32 as libc::c_uint) {
// device-internal message, no further details needed
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT contact_id, timestamp_sent FROM msgs_mdns WHERE msg_id=?;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
dc_strbuilder_cat(&mut ret, b"Read: \x00" as *const u8 as *const libc::c_char);
p = dc_timestamp_to_str(sqlite3_column_int64(stmt, 1i32) as time_t);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
dc_strbuilder_cat(&mut ret, b" by \x00" as *const u8 as *const libc::c_char);
let mut contact: *mut dc_contact_t = dc_contact_new(context);
dc_contact_load_from_db(
contact,
&mut context.sql.clone().lock().unwrap(),
sqlite3_column_int64(stmt, 0i32) as uint32_t,
);
p = dc_contact_get_name_n_addr(contact);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
dc_contact_unref(contact);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
}
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
dc_trim(rawtxt);
dc_truncate_str(rawtxt, 100000i32);
dc_strbuilder_cat(&mut ret, b"Sent: \x00" as *const u8 as *const libc::c_char);
p = dc_timestamp_to_str(dc_msg_get_timestamp(msg));
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
p = dc_contact_get_name_n_addr(contact_from);
p = 0 as *mut libc::c_char;
match (*msg).state {
10 => p = dc_strdup(b"Fresh\x00" as *const u8 as *const libc::c_char),
13 => p = dc_strdup(b"Noticed\x00" as *const u8 as *const libc::c_char),
16 => p = dc_strdup(b"Seen\x00" as *const u8 as *const libc::c_char),
26 => p = dc_strdup(b"Delivered\x00" as *const u8 as *const libc::c_char),
24 => p = dc_strdup(b"Failed\x00" as *const u8 as *const libc::c_char),
28 => p = dc_strdup(b"Read\x00" as *const u8 as *const libc::c_char),
20 => p = dc_strdup(b"Pending\x00" as *const u8 as *const libc::c_char),
18 => p = dc_strdup(b"Preparing\x00" as *const u8 as *const libc::c_char),
_ => p = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, (*msg).state),
}
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b" by %s\x00" as *const u8 as *const libc::c_char,
b"State: %s\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
if (*msg).from_id != 1i32 as libc::c_uint {
if 0 != dc_msg_has_location(msg) {
dc_strbuilder_cat(
&mut ret,
b"Received: \x00" as *const u8 as *const libc::c_char,
b", Location sent\x00" as *const u8 as *const libc::c_char,
);
p = dc_timestamp_to_str(if 0 != (*msg).timestamp_rcvd {
(*msg).timestamp_rcvd
} else {
(*msg).timestamp_sort
});
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
}
if !((*msg).from_id == 2i32 as libc::c_uint || (*msg).to_id == 2i32 as libc::c_uint) {
// device-internal message, no further details needed
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT contact_id, timestamp_sent FROM msgs_mdns WHERE msg_id=?;\x00"
as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
dc_strbuilder_cat(&mut ret, b"Read: \x00" as *const u8 as *const libc::c_char);
p = dc_timestamp_to_str(sqlite3_column_int64(stmt, 1i32) as time_t);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
dc_strbuilder_cat(&mut ret, b" by \x00" as *const u8 as *const libc::c_char);
let mut contact: *mut dc_contact_t = dc_contact_new(context);
dc_contact_load_from_db(
contact,
(*context).sql,
sqlite3_column_int64(stmt, 0i32) as uint32_t,
);
p = dc_contact_get_name_n_addr(contact);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
dc_contact_unref(contact);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
p = 0 as *mut libc::c_char;
e2ee_errors = 0;
e2ee_errors = dc_param_get_int((*msg).param, 'e' as i32, 0i32);
if 0 != e2ee_errors {
if 0 != e2ee_errors & 0x2i32 {
p = dc_strdup(
b"Encrypted, no valid signature\x00" as *const u8 as *const libc::c_char,
)
}
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
} else if 0 != dc_param_get_int((*msg).param, 'c' as i32, 0i32) {
p = dc_strdup(b"Encrypted\x00" as *const u8 as *const libc::c_char)
}
if !p.is_null() {
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b", %s\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
}
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
p = dc_param_get((*msg).param, 'L' as i32, 0 as *const libc::c_char);
if !p.is_null() {
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"Error: %s\n\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
}
p = dc_msg_get_file(msg);
if !p.is_null() && 0 != *p.offset(0isize) as libc::c_int {
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"\nFile: %s, %i bytes\n\x00" as *const u8 as *const libc::c_char,
p,
dc_get_filebytes(context, p) as libc::c_int,
);
}
free(p as *mut libc::c_void);
if (*msg).type_0 != 10i32 {
p = 0 as *mut libc::c_char;
match (*msg).state {
10 => p = dc_strdup(b"Fresh\x00" as *const u8 as *const libc::c_char),
13 => p = dc_strdup(b"Noticed\x00" as *const u8 as *const libc::c_char),
16 => p = dc_strdup(b"Seen\x00" as *const u8 as *const libc::c_char),
26 => p = dc_strdup(b"Delivered\x00" as *const u8 as *const libc::c_char),
24 => p = dc_strdup(b"Failed\x00" as *const u8 as *const libc::c_char),
28 => p = dc_strdup(b"Read\x00" as *const u8 as *const libc::c_char),
20 => p = dc_strdup(b"Pending\x00" as *const u8 as *const libc::c_char),
18 => p = dc_strdup(b"Preparing\x00" as *const u8 as *const libc::c_char),
match (*msg).type_0 {
40 => p = dc_strdup(b"Audio\x00" as *const u8 as *const libc::c_char),
60 => p = dc_strdup(b"File\x00" as *const u8 as *const libc::c_char),
21 => p = dc_strdup(b"GIF\x00" as *const u8 as *const libc::c_char),
20 => p = dc_strdup(b"Image\x00" as *const u8 as *const libc::c_char),
50 => p = dc_strdup(b"Video\x00" as *const u8 as *const libc::c_char),
41 => p = dc_strdup(b"Voice\x00" as *const u8 as *const libc::c_char),
_ => {
p = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, (*msg).state)
p = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, (*msg).type_0)
}
}
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"State: %s\x00" as *const u8 as *const libc::c_char,
b"Type: %s\n\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
if 0 != dc_msg_has_location(msg) {
dc_strbuilder_cat(
&mut ret,
b", Location sent\x00" as *const u8 as *const libc::c_char,
);
}
p = 0 as *mut libc::c_char;
e2ee_errors = 0;
e2ee_errors = dc_param_get_int((*msg).param, 'e' as i32, 0i32);
if 0 != e2ee_errors {
if 0 != e2ee_errors & 0x2i32 {
p = dc_strdup(
b"Encrypted, no valid signature\x00" as *const u8
as *const libc::c_char,
)
}
} else if 0 != dc_param_get_int((*msg).param, 'c' as i32, 0i32) {
p = dc_strdup(b"Encrypted\x00" as *const u8 as *const libc::c_char)
}
if !p.is_null() {
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b", %s\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
}
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
p = dc_param_get((*msg).param, 'L' as i32, 0 as *const libc::c_char);
if !p.is_null() {
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"Error: %s\n\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
}
p = dc_msg_get_file(msg);
if !p.is_null() && 0 != *p.offset(0isize) as libc::c_int {
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"\nFile: %s, %i bytes\n\x00" as *const u8 as *const libc::c_char,
p,
dc_get_filebytes(context, p) as libc::c_int,
);
}
p = dc_msg_get_filemime(msg);
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"Mimetype: %s\n\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
if (*msg).type_0 != 10i32 {
p = 0 as *mut libc::c_char;
match (*msg).type_0 {
40 => p = dc_strdup(b"Audio\x00" as *const u8 as *const libc::c_char),
60 => p = dc_strdup(b"File\x00" as *const u8 as *const libc::c_char),
21 => p = dc_strdup(b"GIF\x00" as *const u8 as *const libc::c_char),
20 => p = dc_strdup(b"Image\x00" as *const u8 as *const libc::c_char),
50 => p = dc_strdup(b"Video\x00" as *const u8 as *const libc::c_char),
41 => p = dc_strdup(b"Voice\x00" as *const u8 as *const libc::c_char),
_ => {
p = dc_mprintf(
b"%i\x00" as *const u8 as *const libc::c_char,
(*msg).type_0,
)
}
}
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"Type: %s\n\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
p = dc_msg_get_filemime(msg);
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"Mimetype: %s\n\x00" as *const u8 as *const libc::c_char,
p,
);
free(p as *mut libc::c_void);
}
w = dc_param_get_int((*msg).param, 'w' as i32, 0i32);
h = dc_param_get_int((*msg).param, 'h' as i32, 0i32);
if w != 0i32 || h != 0i32 {
p = dc_mprintf(
b"Dimension: %i x %i\n\x00" as *const u8 as *const libc::c_char,
w,
h,
);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
}
duration = dc_param_get_int((*msg).param, 'd' as i32, 0i32);
if duration != 0i32 {
p = dc_mprintf(
b"Duration: %i ms\n\x00" as *const u8 as *const libc::c_char,
duration,
);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
}
if !rawtxt.is_null() && 0 != *rawtxt.offset(0isize) as libc::c_int {
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
dc_strbuilder_cat(&mut ret, rawtxt);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
}
if !(*msg).rfc724_mid.is_null()
&& 0 != *(*msg).rfc724_mid.offset(0isize) as libc::c_int
{
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"\nMessage-ID: %s\x00" as *const u8 as *const libc::c_char,
(*msg).rfc724_mid,
);
}
if !(*msg).server_folder.is_null()
&& 0 != *(*msg).server_folder.offset(0isize) as libc::c_int
{
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"\nLast seen as: %s/%i\x00" as *const u8 as *const libc::c_char,
(*msg).server_folder,
(*msg).server_uid as libc::c_int,
);
}
}
w = dc_param_get_int((*msg).param, 'w' as i32, 0i32);
h = dc_param_get_int((*msg).param, 'h' as i32, 0i32);
if w != 0i32 || h != 0i32 {
p = dc_mprintf(
b"Dimension: %i x %i\n\x00" as *const u8 as *const libc::c_char,
w,
h,
);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
}
duration = dc_param_get_int((*msg).param, 'd' as i32, 0i32);
if duration != 0i32 {
p = dc_mprintf(
b"Duration: %i ms\n\x00" as *const u8 as *const libc::c_char,
duration,
);
dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void);
}
if !rawtxt.is_null() && 0 != *rawtxt.offset(0isize) as libc::c_int {
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
dc_strbuilder_cat(&mut ret, rawtxt);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
}
if !(*msg).rfc724_mid.is_null() && 0 != *(*msg).rfc724_mid.offset(0isize) as libc::c_int
{
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"\nMessage-ID: %s\x00" as *const u8 as *const libc::c_char,
(*msg).rfc724_mid,
);
}
if !(*msg).server_folder.is_null()
&& 0 != *(*msg).server_folder.offset(0isize) as libc::c_int
{
dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t,
b"\nLast seen as: %s/%i\x00" as *const u8 as *const libc::c_char,
(*msg).server_folder,
(*msg).server_uid as libc::c_int,
);
}
}
}
sqlite3_finalize(stmt);
dc_msg_unref(msg);
dc_contact_unref(contact_from);
@@ -503,21 +502,19 @@ pub unsafe fn dc_msg_get_timestamp(mut msg: *const dc_msg_t) -> time_t {
(*msg).timestamp_sort
};
}
pub unsafe fn dc_msg_load_from_db(
mut msg: *mut dc_msg_t,
mut context: &dc_context_t,
mut id: uint32_t,
pub unsafe fn dc_msg_load_from_db<'a>(
msg: *mut dc_msg_t<'a>,
context: &'a dc_context_t,
id: uint32_t,
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(msg.is_null()
|| (*msg).magic != 0x11561156i32 as libc::c_uint
|| context.is_null()
|| (*context).sql.is_null())
{
let mut stmt = 0 as *mut sqlite3_stmt;
if !msg.is_null() {
stmt =
dc_sqlite3_prepare((*context).sql,
b"SELECT m.id,rfc724_mid,m.mime_in_reply_to,m.server_folder,m.server_uid,m.move_state,m.chat_id, m.from_id,m.to_id,m.timestamp,m.timestamp_sent,m.timestamp_rcvd, m.type,m.state,m.msgrmsg,m.txt, m.param,m.starred,m.hidden,m.location_id, c.blocked FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE m.id=?;\x00"
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT m.id,rfc724_mid,m.mime_in_reply_to,m.server_folder,m.server_uid,m.move_state,m.chat_id, m.from_id,m.to_id,m.timestamp,m.timestamp_sent,m.timestamp_rcvd, m.type,m.state,m.msgrmsg,m.txt, m.param,m.starred,m.hidden,m.location_id, c.blocked FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE m.id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, id as libc::c_int);
if !(sqlite3_step(stmt) != 100i32) {
@@ -612,18 +609,19 @@ pub unsafe fn dc_get_mime_headers(
mut context: &dc_context_t,
mut msg_id: uint32_t,
) -> *mut libc::c_char {
let mut eml: &libc::c_char = 0 as *mut libc::c_char;
let mut eml = 0 as *mut libc::c_char;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT mime_headers FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
if sqlite3_step(stmt) == 100i32 {
eml = dc_strdup_keep_null(sqlite3_column_text(stmt, 0i32) as *const libc::c_char)
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT mime_headers FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
if sqlite3_step(stmt) == 100i32 {
eml = dc_strdup_keep_null(sqlite3_column_text(stmt, 0i32) as *const libc::c_char)
}
sqlite3_finalize(stmt);
return eml;
}
@@ -632,11 +630,7 @@ pub unsafe fn dc_delete_msgs(
mut msg_ids: *const uint32_t,
mut msg_cnt: libc::c_int,
) {
if context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_ids.is_null()
|| msg_cnt <= 0i32
{
if msg_ids.is_null() || msg_cnt <= 0i32 {
return;
}
let mut i: libc::c_int = 0i32;
@@ -668,8 +662,9 @@ pub unsafe fn dc_update_msg_chat_id(
mut msg_id: uint32_t,
mut chat_id: uint32_t,
) {
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
let stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET chat_id=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -682,20 +677,14 @@ pub unsafe fn dc_markseen_msgs(
mut msg_ids: *const uint32_t,
mut msg_cnt: libc::c_int,
) {
let mut transaction_pending: libc::c_int = 0i32;
let mut i: libc::c_int = 0i32;
let mut send_event: libc::c_int = 0i32;
let mut curr_state: libc::c_int = 0i32;
let mut curr_blocked: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_ids.is_null()
|| msg_cnt <= 0i32)
{
transaction_pending = 1i32;
let mut stmt = 0 as *mut sqlite3_stmt;
if !(msg_ids.is_null() || msg_cnt <= 0i32) {
stmt =
dc_sqlite3_prepare((*context).sql,
dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(),
b"SELECT m.state, c.blocked FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE m.id=? AND m.chat_id>9\x00"
as *const u8 as *const libc::c_char);
i = 0i32;
@@ -730,7 +719,7 @@ pub unsafe fn dc_markseen_msgs(
}
i += 1
}
transaction_pending = 0i32;
if 0 != send_event {
((*context).cb)(
context,
@@ -747,7 +736,8 @@ pub unsafe fn dc_update_msg_state(
mut msg_id: uint32_t,
mut state: libc::c_int,
) {
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare(
let mut stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -762,16 +752,12 @@ pub unsafe fn dc_star_msgs(
mut msg_cnt: libc::c_int,
mut star: libc::c_int,
) {
if context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_ids.is_null()
|| msg_cnt <= 0i32
|| star != 0i32 && star != 1i32
{
if msg_ids.is_null() || msg_cnt <= 0i32 || star != 0i32 && star != 1i32 {
return;
}
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
let mut stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET starred=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
let mut i: libc::c_int = 0i32;
@@ -794,7 +780,7 @@ pub unsafe fn dc_get_msg<'a>(context: &'a dc_context_t, msg_id: uint32_t) -> *mu
obj
} else {
dc_msg_unref(obj);
0 as &dc_msg_t
0 as *mut dc_msg_t
}
}
@@ -900,7 +886,7 @@ pub unsafe fn dc_msg_get_duration(mut msg: *const dc_msg_t) -> libc::c_int {
return dc_param_get_int((*msg).param, 'd' as i32, 0i32);
}
pub unsafe fn dc_msg_get_showpadlock(mut msg: *const dc_msg_t) -> libc::c_int {
if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint || (*msg).context.is_null() {
if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
return 0i32;
}
if dc_param_get_int((*msg).param, 'c' as i32, 0i32) != 0i32 {
@@ -908,9 +894,9 @@ pub unsafe fn dc_msg_get_showpadlock(mut msg: *const dc_msg_t) -> libc::c_int {
}
return 0i32;
}
pub unsafe fn dc_msg_get_summary(
mut msg: *const dc_msg_t,
mut chat: *const dc_chat_t,
pub unsafe fn dc_msg_get_summary<'a>(
msg: *const dc_msg_t<'a>,
mut chat: *const dc_chat_t<'a>,
) -> *mut dc_lot_t {
let mut current_block: u64;
let mut ret: *mut dc_lot_t = dc_lot_new();
@@ -968,7 +954,7 @@ pub unsafe fn dc_msg_get_summarytext_by_raw(
mut context: &dc_context_t,
) -> *mut libc::c_char {
/* get a summary text, result must be free()'d, never returns NULL. */
let mut ret: &libc::c_char = 0 as *mut libc::c_char;
let mut ret = 0 as *mut libc::c_char;
let mut prefix: *mut libc::c_char = 0 as *mut libc::c_char;
let mut pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
let mut label: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -1075,7 +1061,7 @@ pub unsafe fn dc_msg_is_info(mut msg: *const dc_msg_t) -> libc::c_int {
return 0i32;
}
pub unsafe fn dc_msg_is_increation(mut msg: *const dc_msg_t) -> libc::c_int {
if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint || (*msg).context.is_null() {
if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
return 0i32;
}
return (((*msg).type_0 == 20i32
@@ -1198,15 +1184,12 @@ pub unsafe fn dc_msg_latefiling_mediasize(
};
}
pub unsafe fn dc_msg_save_param_to_disk(mut msg: *mut dc_msg_t) {
if msg.is_null()
|| (*msg).magic != 0x11561156i32 as libc::c_uint
|| (*msg).context.is_null()
|| (*(*msg).context).sql.is_null()
{
if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
return;
}
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
(*(*msg).context).sql,
(*msg).context,
&mut (*msg).context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET param=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_text(stmt, 1i32, (*(*msg).param).packed, -1i32, None);
@@ -1218,7 +1201,7 @@ pub unsafe fn dc_msg_new_load<'a>(
context: &'a dc_context_t,
msg_id: uint32_t,
) -> *mut dc_msg_t<'a> {
let mut msg: &dc_msg_t = dc_msg_new_untyped(context);
let mut msg = dc_msg_new_untyped(context);
dc_msg_load_from_db(msg, context, msg_id);
msg
}
@@ -1228,15 +1211,17 @@ pub unsafe fn dc_delete_msg_from_db(context: &dc_context_t, mut msg_id: uint32_t
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(0 == dc_msg_load_from_db(msg, context, msg_id)) {
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, (*msg).id as libc::c_int);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
stmt = 0 as &sqlite3_stmt;
stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM msgs_mdns WHERE msg_id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, (*msg).id as libc::c_int);
@@ -1255,12 +1240,10 @@ The value is also used for CC:-summaries */
pub unsafe fn dc_msg_exists(mut context: &dc_context_t, mut msg_id: uint32_t) -> libc::c_int {
let mut msg_exists: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_id <= 9i32 as libc::c_uint)
{
if !msg_id <= 9i32 as libc::c_uint {
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT chat_id FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
@@ -1281,8 +1264,9 @@ pub unsafe fn dc_update_msg_move_state(
) {
// we update the move_state for all messages belonging to a given Message-ID
// so that the state stay intact when parts are deleted
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
let mut stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET move_state=? WHERE rfc724_mid=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, state as libc::c_int);
@@ -1295,7 +1279,7 @@ pub unsafe fn dc_set_msg_failed(
mut msg_id: uint32_t,
mut error: *const libc::c_char,
) {
let mut msg: &dc_msg_t = dc_msg_new_untyped(context);
let mut msg = dc_msg_new_untyped(context);
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(0 == dc_msg_load_from_db(msg, context, msg_id)) {
if 18i32 == (*msg).state || 20i32 == (*msg).state || 26i32 == (*msg).state {
@@ -1311,7 +1295,8 @@ pub unsafe fn dc_set_msg_failed(
);
}
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET state=?, param=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, (*msg).state);
@@ -1334,7 +1319,7 @@ pub unsafe fn dc_mdn_from_ext(
mut from_id: uint32_t,
mut rfc724_mid: *const libc::c_char,
mut timestamp_sent: time_t,
mut ret_chat_id: &uint32_t,
mut ret_chat_id: *mut uint32_t,
mut ret_msg_id: *mut uint32_t,
) -> libc::c_int {
let mut chat_type: libc::c_int = 0;
@@ -1344,9 +1329,7 @@ pub unsafe fn dc_mdn_from_ext(
let mut soll_cnt: libc::c_int = 0;
let mut read_by_all: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| from_id <= 9i32 as libc::c_uint
if !(from_id <= 9i32 as libc::c_uint
|| rfc724_mid.is_null()
|| ret_chat_id.is_null()
|| ret_msg_id.is_null()
@@ -1354,9 +1337,12 @@ pub unsafe fn dc_mdn_from_ext(
|| *ret_msg_id != 0i32 as libc::c_uint)
{
stmt =
dc_sqlite3_prepare((*context).sql,
b"SELECT m.id, c.id, c.type, m.state FROM msgs m LEFT JOIN chats c ON m.chat_id=c.id WHERE rfc724_mid=? AND from_id=1 ORDER BY m.id;\x00"
as *const u8 as *const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT m.id, c.id, c.type, m.state FROM msgs m LEFT JOIN chats c ON m.chat_id=c.id WHERE rfc724_mid=? AND from_id=1 ORDER BY m.id;\x00"
as *const u8 as *const libc::c_char
);
sqlite3_bind_text(stmt, 1i32, rfc724_mid, -1i32, None);
if !(sqlite3_step(stmt) != 100i32) {
*ret_msg_id = sqlite3_column_int(stmt, 0i32) as uint32_t;
@@ -1368,7 +1354,8 @@ pub unsafe fn dc_mdn_from_ext(
if !(msg_state != 18i32 && msg_state != 20i32 && msg_state != 26i32) {
/* eg. already marked as MDNS_RCVD. however, it is importent, that the message ID is set above as this will allow the caller eg. to move the message away */
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT contact_id FROM msgs_mdns WHERE msg_id=? AND contact_id=?;\x00"
as *const u8 as *const libc::c_char,
);
@@ -1383,10 +1370,12 @@ pub unsafe fn dc_mdn_from_ext(
stmt = 0 as *mut sqlite3_stmt;
if 0 == mdn_already_in_table {
stmt =
dc_sqlite3_prepare((*context).sql,
b"INSERT INTO msgs_mdns (msg_id, contact_id, timestamp_sent) VALUES (?, ?, ?);\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO msgs_mdns (msg_id, contact_id, timestamp_sent) VALUES (?, ?, ?);\x00"
as *const u8 as
*const libc::c_char);
sqlite3_bind_int(stmt, 1i32, *ret_msg_id as libc::c_int);
sqlite3_bind_int(stmt, 2i32, from_id as libc::c_int);
sqlite3_bind_int64(stmt, 3i32, timestamp_sent as sqlite3_int64);
@@ -1401,7 +1390,8 @@ pub unsafe fn dc_mdn_from_ext(
} else {
/* send event about new state */
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -1442,14 +1432,17 @@ pub unsafe fn dc_mdn_from_ext(
pub unsafe fn dc_get_real_msg_cnt(mut context: &dc_context_t) -> size_t {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut ret: size_t = 0i32 as size_t;
if !(*(*context).sql).cobj.is_null() {
if !(*&mut context.sql.clone().lock().unwrap()).cobj.is_null() {
stmt =
dc_sqlite3_prepare((*context).sql,
b"SELECT COUNT(*) FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE m.id>9 AND m.chat_id>9 AND c.blocked=0;\x00"
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE m.id>9 AND m.chat_id>9 AND c.blocked=0;\x00"
as *const u8 as *const libc::c_char);
if sqlite3_step(stmt) != 100i32 {
dc_sqlite3_log_error(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"dc_get_real_msg_cnt() failed.\x00" as *const u8 as *const libc::c_char,
);
} else {
@@ -1462,12 +1455,9 @@ pub unsafe fn dc_get_real_msg_cnt(mut context: &dc_context_t) -> size_t {
pub unsafe fn dc_get_deaddrop_msg_cnt(mut context: &dc_context_t) -> size_t {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut ret: size_t = 0i32 as size_t;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| (*(*context).sql).cobj.is_null())
{
if !context.sql.clone().lock().unwrap().cobj.is_null() {
stmt =
dc_sqlite3_prepare((*context).sql,
dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id WHERE c.blocked=2;\x00"
as *const u8 as *const libc::c_char);
if !(sqlite3_step(stmt) != 100i32) {
@@ -1483,13 +1473,11 @@ pub unsafe fn dc_rfc724_mid_cnt(
) -> libc::c_int {
/* check the number of messages with the same rfc724_mid */
let mut ret: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| (*(*context).sql).cobj.is_null())
{
let mut stmt = 0 as *mut sqlite3_stmt;
if !context.sql.clone().lock().unwrap().cobj.is_null() {
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM msgs WHERE rfc724_mid=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -1505,16 +1493,14 @@ pub unsafe fn dc_rfc724_mid_exists(
mut context: &dc_context_t,
mut rfc724_mid: *const libc::c_char,
mut ret_server_folder: *mut *mut libc::c_char,
mut ret_server_uid: &uint32_t,
mut ret_server_uid: *mut uint32_t,
) -> uint32_t {
let mut ret: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null()
|| rfc724_mid.is_null()
|| *rfc724_mid.offset(0isize) as libc::c_int == 0i32)
{
if !(rfc724_mid.is_null() || *rfc724_mid.offset(0isize) as libc::c_int == 0i32) {
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT server_folder, server_uid, id FROM msgs WHERE rfc724_mid=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -1545,8 +1531,9 @@ pub unsafe fn dc_update_server_uid(
mut server_folder: *const libc::c_char,
mut server_uid: uint32_t,
) {
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
let mut stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET server_folder=?, server_uid=? WHERE rfc724_mid=?;\x00" as *const u8
as *const libc::c_char,
);

77
src/dc_oauth2.rs
View File

@@ -28,15 +28,12 @@ pub unsafe fn dc_get_oauth2_url(
) -> *mut libc::c_char {
let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t;
let mut oauth2_url: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| redirect_uri.is_null()
|| *redirect_uri.offset(0isize) as libc::c_int == 0i32)
{
if !(redirect_uri.is_null() || *redirect_uri.offset(0isize) as libc::c_int == 0i32) {
oauth2 = get_info(addr);
if !oauth2.is_null() {
dc_sqlite3_set_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_pending_redirect_uri\x00" as *const u8 as *const libc::c_char,
redirect_uri,
);
@@ -154,12 +151,7 @@ pub unsafe fn dc_get_oauth2_access_token(
size: 0,
}; 128];
let mut tok_cnt: libc::c_int = 0i32;
let mut locked: libc::c_int = 0i32;
if context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| code.is_null()
|| *code.offset(0isize) as libc::c_int == 0i32
{
if code.is_null() || *code.offset(0isize) as libc::c_int == 0i32 {
dc_log_warning(
context,
0i32,
@@ -174,12 +166,14 @@ pub unsafe fn dc_get_oauth2_access_token(
b"Internal OAuth2 error: 2\x00" as *const u8 as *const libc::c_char,
);
} else {
pthread_mutex_lock(&mut (*context).oauth2_critical);
locked = 1i32;
let lock = context.oauth2_critical.clone();
let l = lock.lock().unwrap();
// read generated token
if 0 == flags & 0x1i32 && 0 == is_expired(context) {
access_token = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_access_token\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
@@ -196,12 +190,14 @@ pub unsafe fn dc_get_oauth2_access_token(
16914036240511706173 => {}
_ => {
refresh_token = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_refresh_token\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
refresh_token_for = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_refresh_token_for\x00" as *const u8 as *const libc::c_char,
b"unset\x00" as *const u8 as *const libc::c_char,
);
@@ -213,7 +209,8 @@ pub unsafe fn dc_get_oauth2_access_token(
as *const libc::c_char,
);
redirect_uri = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_pending_redirect_uri\x00" as *const u8 as *const libc::c_char,
b"unset\x00" as *const u8 as *const libc::c_char,
);
@@ -227,7 +224,8 @@ pub unsafe fn dc_get_oauth2_access_token(
as *const libc::c_char,
);
redirect_uri = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_redirect_uri\x00" as *const u8 as *const libc::c_char,
b"unset\x00" as *const u8 as *const libc::c_char,
);
@@ -253,7 +251,7 @@ pub unsafe fn dc_get_oauth2_access_token(
b"$REFRESH_TOKEN\x00" as *const u8 as *const libc::c_char,
refresh_token,
);
json = ((*context).cb)(
json = (context.cb)(
context,
Event::HTTP_POST,
token_url as uintptr_t,
@@ -381,12 +379,14 @@ pub unsafe fn dc_get_oauth2_access_token(
&& 0 != *refresh_token.offset(0isize) as libc::c_int
{
dc_sqlite3_set_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_refresh_token\x00" as *const u8 as *const libc::c_char,
refresh_token,
);
dc_sqlite3_set_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_refresh_token_for\x00" as *const u8
as *const libc::c_char,
code,
@@ -405,12 +405,14 @@ pub unsafe fn dc_get_oauth2_access_token(
);
} else {
dc_sqlite3_set_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_access_token\x00" as *const u8 as *const libc::c_char,
access_token,
);
dc_sqlite3_set_config_int64(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_timestamp_expires\x00" as *const u8
as *const libc::c_char,
(if 0 != expires_in {
@@ -421,7 +423,8 @@ pub unsafe fn dc_get_oauth2_access_token(
);
if 0 != update_redirect_uri_on_success {
dc_sqlite3_set_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_redirect_uri\x00" as *const u8
as *const libc::c_char,
redirect_uri,
@@ -432,11 +435,9 @@ pub unsafe fn dc_get_oauth2_access_token(
}
}
}
drop(l);
}
}
if 0 != locked {
pthread_mutex_unlock(&mut (*context).oauth2_critical);
}
free(refresh_token as *mut libc::c_void);
free(refresh_token_for as *mut libc::c_void);
free(redirect_uri as *mut libc::c_void);
@@ -481,7 +482,8 @@ unsafe extern "C" fn jsoneq(
}
unsafe fn is_expired(mut context: &dc_context_t) -> libc::c_int {
let mut expire_timestamp: time_t = dc_sqlite3_get_config_int64(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_timestamp_expires\x00" as *const u8 as *const libc::c_char,
0i32 as int64_t,
) as time_t;
@@ -501,13 +503,10 @@ pub unsafe fn dc_get_oauth2_addr(
let mut access_token: *mut libc::c_char = 0 as *mut libc::c_char;
let mut addr_out: *mut libc::c_char = 0 as *mut libc::c_char;
let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| {
oauth2 = get_info(addr);
oauth2.is_null()
}
|| (*oauth2).get_userinfo.is_null())
if !({
oauth2 = get_info(addr);
oauth2.is_null()
} || (*oauth2).get_userinfo.is_null())
{
access_token = dc_get_oauth2_access_token(context, addr, code, 0i32);
addr_out = get_oauth2_addr(context, oauth2, access_token);
@@ -542,9 +541,7 @@ unsafe fn get_oauth2_addr(
size: 0,
}; 128];
let mut tok_cnt: libc::c_int = 0i32;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| access_token.is_null()
if !(access_token.is_null()
|| *access_token.offset(0isize) as libc::c_int == 0i32
|| oauth2.is_null())
{
@@ -554,7 +551,7 @@ unsafe fn get_oauth2_addr(
b"$ACCESS_TOKEN\x00" as *const u8 as *const libc::c_char,
access_token,
);
json = ((*context).cb)(
json = (context.cb)(
context,
Event::HTTP_GET,
userinfo_url as uintptr_t,

6
src/dc_param.rs
View File

@@ -119,9 +119,9 @@ unsafe extern "C" fn find_param(
}
/* the value may be an empty string, "def" is returned only if the value unset. The result must be free()'d in any case. */
pub unsafe fn dc_param_get(
mut param: *const dc_param_t,
mut key: libc::c_int,
mut def: *const libc::c_char,
param: *const dc_param_t,
key: libc::c_int,
def: *const libc::c_char,
) -> *mut libc::c_char {
let mut p1: *mut libc::c_char = 0 as *mut libc::c_char;
let mut p2: *mut libc::c_char = 0 as *mut libc::c_char;

42
src/dc_pgp.rs
View File

@@ -197,14 +197,12 @@ pub unsafe fn dc_pgp_handle_rpgp_error(mut context: &dc_context_t) -> libc::c_in
len = rpgp::rpgp_last_error_length();
if !(len == 0i32) {
msg = rpgp::rpgp_last_error_message();
if !context.is_null() {
dc_log_info(
context,
0i32,
b"[rpgp][error] %s\x00" as *const u8 as *const libc::c_char,
msg,
);
}
dc_log_info(
context,
0i32,
b"[rpgp][error] %s\x00" as *const u8 as *const libc::c_char,
msg,
);
success = 1i32
}
if !msg.is_null() {
@@ -218,11 +216,7 @@ pub unsafe fn dc_pgp_is_valid_key(
) -> libc::c_int {
let mut key_is_valid: libc::c_int = 0i32;
let mut key: *mut rpgp::public_or_secret_key = 0 as *mut rpgp::public_or_secret_key;
if !(context.is_null()
|| raw_key.is_null()
|| (*raw_key).binary.is_null()
|| (*raw_key).bytes <= 0i32)
{
if !(raw_key.is_null() || (*raw_key).binary.is_null() || (*raw_key).bytes <= 0i32) {
key = rpgp::rpgp_key_from_bytes(
(*raw_key).binary as *const uint8_t,
(*raw_key).bytes as usize,
@@ -242,9 +236,10 @@ pub unsafe fn dc_pgp_is_valid_key(
return key_is_valid;
}
pub unsafe fn dc_pgp_calc_fingerprint(
mut raw_key: *const dc_key_t,
mut ret_fingerprint: *mut *mut uint8_t,
mut ret_fingerprint_bytes: *mut size_t,
context: &dc_context_t,
raw_key: *const dc_key_t,
ret_fingerprint: *mut *mut uint8_t,
ret_fingerprint_bytes: *mut size_t,
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut key: *mut rpgp::public_or_secret_key = 0 as *mut rpgp::public_or_secret_key;
@@ -261,9 +256,9 @@ pub unsafe fn dc_pgp_calc_fingerprint(
(*raw_key).binary as *const uint8_t,
(*raw_key).bytes as usize,
);
if !(0 != dc_pgp_handle_rpgp_error(0 as &dc_context_t)) {
if !(0 != dc_pgp_handle_rpgp_error(context)) {
fingerprint = rpgp::rpgp_key_fingerprint(key);
if !(0 != dc_pgp_handle_rpgp_error(0 as &dc_context_t)) {
if !(0 != dc_pgp_handle_rpgp_error(context)) {
*ret_fingerprint_bytes = rpgp::rpgp_cvec_len(fingerprint) as size_t;
*ret_fingerprint = malloc(*ret_fingerprint_bytes) as *mut uint8_t;
memcpy(
@@ -292,7 +287,7 @@ pub unsafe fn dc_pgp_split_key(
let mut key: *mut rpgp::signed_secret_key = 0 as *mut rpgp::signed_secret_key;
let mut pub_key: *mut rpgp::signed_public_key = 0 as *mut rpgp::signed_public_key;
let mut buf: *mut rpgp::cvec = 0 as *mut rpgp::cvec;
if !(context.is_null() || private_in.is_null() || ret_public_key.is_null()) {
if !(private_in.is_null() || ret_public_key.is_null()) {
if (*private_in).type_0 != 1i32 {
dc_log_warning(
context,
@@ -349,8 +344,7 @@ pub unsafe fn dc_pgp_pk_encrypt(
let mut public_keys: *mut *mut rpgp::signed_public_key = 0 as *mut *mut rpgp::signed_public_key;
let mut private_key: *mut rpgp::signed_secret_key = 0 as *mut rpgp::signed_secret_key;
let mut encrypted: *mut rpgp::Message = 0 as *mut rpgp::Message;
if !(context.is_null()
|| plain_text == 0 as *mut libc::c_void
if !(plain_text == 0 as *mut libc::c_void
|| plain_bytes == 0
|| ret_ctext.is_null()
|| ret_ctext_bytes.is_null()
@@ -522,8 +516,7 @@ pub unsafe fn dc_pgp_pk_decrypt(
let mut private_keys: *mut *mut rpgp::signed_secret_key =
0 as *mut *mut rpgp::signed_secret_key;
let mut public_keys: *mut *mut rpgp::signed_public_key = 0 as *mut *mut rpgp::signed_public_key;
if !(context.is_null()
|| ctext == 0 as *mut libc::c_void
if !(ctext == 0 as *mut libc::c_void
|| ctext_bytes == 0
|| ret_plain.is_null()
|| ret_plain_bytes.is_null()
@@ -673,8 +666,7 @@ pub unsafe fn dc_pgp_symm_encrypt(
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut decrypted: *mut rpgp::Message = 0 as *mut rpgp::Message;
if !(context.is_null()
|| passphrase.is_null()
if !(passphrase.is_null()
|| plain == 0 as *mut libc::c_void
|| plain_bytes == 0
|| ret_ctext_armored.is_null())

4
src/dc_qr.rs
View File

@@ -43,7 +43,7 @@ pub unsafe fn dc_check_qr(
let mut grpid: *mut libc::c_char = 0 as *mut libc::c_char;
let mut grpname: *mut libc::c_char = 0 as *mut libc::c_char;
(*qr_parsed).state = 0i32;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || qr.is_null()) {
if !qr.is_null() {
dc_log_info(
context,
0i32,
@@ -247,7 +247,7 @@ pub unsafe fn dc_check_qr(
if addr.is_null() || invitenumber.is_null() || auth.is_null() {
if 0 != dc_apeerstate_load_by_fingerprint(
peerstate,
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
fingerprint,
) {
(*qr_parsed).state = 210i32;

183
src/dc_receive_imf.rs
View File

@@ -57,7 +57,6 @@ pub unsafe fn dc_receive_imf(
let mut sent_timestamp: time_t = -1i32 as time_t;
let mut rcvd_timestamp: time_t = -1i32 as time_t;
let mut mime_parser: *mut dc_mimeparser_t = dc_mimeparser_new((*context).blobdir, context);
let mut transaction_pending: libc::c_int = 0i32;
let mut field: *const mailimf_field = 0 as *const mailimf_field;
let mut mime_in_reply_to: *mut libc::c_char = 0 as *mut libc::c_char;
let mut mime_references: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -76,7 +75,7 @@ pub unsafe fn dc_receive_imf(
},
server_uid,
);
to_ids = dc_array_new(context, 16i32 as size_t);
to_ids = dc_array_new(16i32 as size_t);
if to_ids.is_null()
|| created_db_entries.is_null()
|| rr_event_to_send.is_null()
@@ -107,7 +106,6 @@ pub unsafe fn dc_receive_imf(
sent_timestamp = dc_timestamp_from_date((*orig_date).dt_date_time)
}
}
transaction_pending = 1i32;
field = dc_mimeparser_lookup_field(
mime_parser,
b"From\x00" as *const u8 as *const libc::c_char,
@@ -116,7 +114,7 @@ pub unsafe fn dc_receive_imf(
let mut fld_from: *mut mailimf_from = (*field).fld_data.fld_from;
if !fld_from.is_null() {
let mut check_self: libc::c_int = 0;
let mut from_list: *mut dc_array_t = dc_array_new(context, 16i32 as size_t);
let mut from_list: *mut dc_array_t = dc_array_new(16i32 as size_t);
dc_add_or_lookup_contacts_by_mailbox_list(
context,
(*fld_from).frm_mb_list,
@@ -225,7 +223,6 @@ pub unsafe fn dc_receive_imf(
if strcmp(old_server_folder, server_folder) != 0i32
|| old_server_uid != server_uid
{
transaction_pending = 0i32;
dc_update_server_uid(
context,
rfc724_mid,
@@ -253,7 +250,8 @@ pub unsafe fn dc_receive_imf(
let mut allow_creation: libc::c_int = 1i32;
if msgrmsg == 0i32 {
let mut show_emails: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"show_emails\x00" as *const u8 as *const libc::c_char,
0i32,
);
@@ -465,7 +463,8 @@ pub unsafe fn dc_receive_imf(
// if the mime-headers should be saved, find out its size
// (the mime-header ends with an empty line)
let mut save_mime_headers: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"save_mime_headers\x00" as *const u8 as *const libc::c_char,
0i32,
);
@@ -529,8 +528,10 @@ pub unsafe fn dc_receive_imf(
}
icnt = carray_count((*mime_parser).parts) as size_t;
stmt =
dc_sqlite3_prepare((*context).sql,
b"INSERT INTO msgs (rfc724_mid, server_folder, server_uid, chat_id, from_id, to_id, timestamp, timestamp_sent, timestamp_rcvd, type, state, msgrmsg, txt, txt_raw, param, bytes, hidden, mime_headers, mime_in_reply_to, mime_references) VALUES (?,?,?,?,?,?, ?,?,?,?,?,?, ?,?,?,?,?,?, ?,?);\x00"
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO msgs (rfc724_mid, server_folder, server_uid, chat_id, from_id, to_id, timestamp, timestamp_sent, timestamp_rcvd, type, state, msgrmsg, txt, txt_raw, param, bytes, hidden, mime_headers, mime_in_reply_to, mime_references) VALUES (?,?,?,?,?,?, ?,?,?,?,?,?, ?,?,?,?,?,?, ?,?);\x00"
as *const u8 as
*const libc::c_char);
i = 0i32 as size_t;
@@ -646,7 +647,8 @@ pub unsafe fn dc_receive_imf(
free(txt_raw as *mut libc::c_void);
txt_raw = 0 as *mut libc::c_char;
insert_msg_id = dc_sqlite3_get_rowid(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"msgs\x00" as *const u8 as *const libc::c_char,
b"rfc724_mid\x00" as *const u8 as *const libc::c_char,
rfc724_mid,
@@ -706,7 +708,8 @@ pub unsafe fn dc_receive_imf(
_ => {
if carray_count((*mime_parser).reports) > 0i32 as libc::c_uint {
let mut mdns_enabled: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
);
@@ -897,7 +900,8 @@ pub unsafe fn dc_receive_imf(
dc_param_set_int(param, 'z' as i32, server_uid as int32_t);
if 0 != (*mime_parser).is_send_by_messenger
&& 0 != dc_sqlite3_get_config_int(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_move\x00" as *const u8
as *const libc::c_char,
1i32,
@@ -984,7 +988,6 @@ pub unsafe fn dc_receive_imf(
0i32,
);
}
transaction_pending = 0i32
}
}
}
@@ -1051,7 +1054,8 @@ unsafe fn calc_timestamps(
*sort_timestamp = message_timestamp;
if 0 != is_fresh_msg {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT MAX(timestamp) FROM msgs WHERE chat_id=? and from_id!=? AND timestamp>=?\x00"
as *const u8 as *const libc::c_char,
);
@@ -1313,7 +1317,8 @@ unsafe fn create_or_lookup_group(
/* check if the group does not exist but should be created */
group_explicitly_left = dc_is_group_explicitly_left(context, grpid);
self_addr = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
@@ -1391,7 +1396,8 @@ unsafe fn create_or_lookup_group(
&& strlen(grpname) < 200
{
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET name=? WHERE id=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -1460,7 +1466,8 @@ unsafe fn create_or_lookup_group(
0 as *mut libc::c_char
};
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM chats_contacts WHERE chat_id=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -1593,7 +1600,7 @@ unsafe fn create_or_lookup_adhoc_group(
sqlite3_mprintf(b"SELECT c.id, c.blocked FROM chats c LEFT JOIN msgs m ON m.chat_id=c.id WHERE c.id IN(%s) ORDER BY m.timestamp DESC, m.id DESC LIMIT 1;\x00"
as *const u8 as *const libc::c_char,
chat_ids_str);
stmt = dc_sqlite3_prepare((*context).sql, q3);
stmt = dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(), q3);
if sqlite3_step(stmt) == 100i32 {
chat_id = sqlite3_column_int(stmt, 0i32) as uint32_t;
chat_id_blocked = sqlite3_column_int(stmt, 1i32);
@@ -1674,7 +1681,8 @@ unsafe fn create_group_record(
let mut chat_id: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO chats (type, name, grpid, blocked) VALUES(?, ?, ?, ?);\x00" as *const u8
as *const libc::c_char,
);
@@ -1688,7 +1696,8 @@ unsafe fn create_group_record(
sqlite3_bind_int(stmt, 4i32, create_blocked);
if !(sqlite3_step(stmt) != 101i32) {
chat_id = dc_sqlite3_get_rowid(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"chats\x00" as *const u8 as *const libc::c_char,
b"grpid\x00" as *const u8 as *const libc::c_char,
grpid,
@@ -1707,7 +1716,7 @@ unsafe fn create_adhoc_grp_id(
- 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])
*/
let mut member_addrs: *mut dc_array_t = dc_array_new(context, 23i32 as size_t);
let mut member_addrs: *mut dc_array_t = dc_array_new(23i32 as size_t);
let mut member_ids_str: *mut libc::c_char =
dc_array_get_string(member_ids, b",\x00" as *const u8 as *const libc::c_char);
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
@@ -1728,9 +1737,10 @@ unsafe fn create_adhoc_grp_id(
as *const libc::c_char,
member_ids_str,
);
stmt = dc_sqlite3_prepare((*context).sql, q3);
stmt = dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(), q3);
addr = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"no-self\x00" as *const u8 as *const libc::c_char,
);
@@ -1788,62 +1798,62 @@ unsafe fn search_chat_ids_by_contact_ids(
) -> *mut dc_array_t {
/* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut contact_ids: *mut dc_array_t = dc_array_new(context, 23i32 as size_t);
let mut contact_ids: *mut dc_array_t = dc_array_new(23i32 as size_t);
let mut contact_ids_str: *mut libc::c_char = 0 as *mut libc::c_char;
let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
let mut chat_ids: *mut dc_array_t = dc_array_new(context, 23i32 as size_t);
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
/* copy array, remove duplicates and SELF, sort by ID */
let mut i: libc::c_int = 0;
let mut iCnt: libc::c_int = dc_array_get_cnt(unsorted_contact_ids) as libc::c_int;
if !(iCnt <= 0i32) {
i = 0i32;
while i < iCnt {
let mut curr_id: uint32_t = dc_array_get_id(unsorted_contact_ids, i as size_t);
if curr_id != 1i32 as libc::c_uint
&& 0 == dc_array_search_id(contact_ids, curr_id, 0 as *mut size_t)
{
dc_array_add_id(contact_ids, curr_id);
}
i += 1
let mut chat_ids: *mut dc_array_t = dc_array_new(23i32 as size_t);
/* copy array, remove duplicates and SELF, sort by ID */
let mut i: libc::c_int = 0;
let mut iCnt: libc::c_int = dc_array_get_cnt(unsorted_contact_ids) as libc::c_int;
if !(iCnt <= 0i32) {
i = 0i32;
while i < iCnt {
let mut curr_id: uint32_t = dc_array_get_id(unsorted_contact_ids, i as size_t);
if curr_id != 1i32 as libc::c_uint
&& 0 == dc_array_search_id(contact_ids, curr_id, 0 as *mut size_t)
{
dc_array_add_id(contact_ids, curr_id);
}
if !(dc_array_get_cnt(contact_ids) == 0) {
dc_array_sort_ids(contact_ids);
contact_ids_str =
dc_array_get_string(contact_ids, b",\x00" as *const u8 as *const libc::c_char);
q3 =
i += 1
}
if !(dc_array_get_cnt(contact_ids) == 0) {
dc_array_sort_ids(contact_ids);
contact_ids_str =
dc_array_get_string(contact_ids, b",\x00" as *const u8 as *const libc::c_char);
q3 =
sqlite3_mprintf(b"SELECT DISTINCT cc.chat_id, cc.contact_id FROM chats_contacts cc LEFT JOIN chats c ON c.id=cc.chat_id WHERE cc.chat_id IN(SELECT chat_id FROM chats_contacts WHERE contact_id IN(%s)) AND c.type=120 AND cc.contact_id!=1 ORDER BY cc.chat_id, cc.contact_id;\x00"
as *const u8 as *const libc::c_char,
contact_ids_str);
stmt = dc_sqlite3_prepare((*context).sql, q3);
let mut last_chat_id = 0;
let mut matches = 0;
let mut mismatches = 0;
while sqlite3_step(stmt) == 100 {
let mut chat_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let mut contact_id: uint32_t = sqlite3_column_int(stmt, 1i32) as uint32_t;
if chat_id != last_chat_id {
if matches == dc_array_get_cnt(contact_ids)
&& mismatches == 0i32 as libc::c_uint
{
dc_array_add_id(chat_ids, last_chat_id);
}
last_chat_id = chat_id;
matches = 0;
mismatches = 0;
}
if contact_id == dc_array_get_id(contact_ids, matches as size_t) {
matches = matches.wrapping_add(1)
} else {
mismatches = mismatches.wrapping_add(1)
stmt = dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(), q3);
let mut last_chat_id = 0;
let mut matches = 0;
let mut mismatches = 0;
while sqlite3_step(stmt) == 100 {
let mut chat_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let mut contact_id: uint32_t = sqlite3_column_int(stmt, 1i32) as uint32_t;
if chat_id != last_chat_id {
if matches == dc_array_get_cnt(contact_ids)
&& mismatches == 0i32 as libc::c_uint
{
dc_array_add_id(chat_ids, last_chat_id);
}
last_chat_id = chat_id;
matches = 0;
mismatches = 0;
}
if matches == dc_array_get_cnt(contact_ids) && mismatches == 0 {
dc_array_add_id(chat_ids, last_chat_id);
if contact_id == dc_array_get_id(contact_ids, matches as size_t) {
matches = matches.wrapping_add(1)
} else {
mismatches = mismatches.wrapping_add(1)
}
}
if matches == dc_array_get_cnt(contact_ids) && mismatches == 0 {
dc_array_add_id(chat_ids, last_chat_id);
}
}
}
sqlite3_finalize(stmt);
free(contact_ids_str as *mut libc::c_void);
dc_array_unref(contact_ids);
@@ -1864,7 +1874,7 @@ unsafe fn check_verified_properties(
let mut to_ids_str: *mut libc::c_char = 0 as *mut libc::c_char;
let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if 0 == dc_contact_load_from_db(contact, (*context).sql, from_id) {
if 0 == dc_contact_load_from_db(contact, &mut context.sql.clone().lock().unwrap(), from_id) {
*failure_reason = dc_mprintf(
b"%s. See \"Info\" for details.\x00" as *const u8 as *const libc::c_char,
b"Internal Error; cannot load contact.\x00" as *const u8 as *const libc::c_char,
@@ -1882,8 +1892,11 @@ unsafe fn check_verified_properties(
// this check is skipped for SELF as there is no proper SELF-peerstate
// and results in group-splits otherwise.
if from_id != 1i32 as libc::c_uint {
if 0 == dc_apeerstate_load_by_addr(peerstate, (*context).sql, (*contact).addr)
|| dc_contact_is_verified_ex(contact, peerstate) != 2i32
if 0 == dc_apeerstate_load_by_addr(
peerstate,
&mut context.sql.clone().lock().unwrap(),
(*contact).addr,
) || dc_contact_is_verified_ex(contact, peerstate) != 2i32
{
*failure_reason = dc_mprintf(
b"%s. See \"Info\" for details.\x00" as *const u8 as *const libc::c_char,
@@ -1920,7 +1933,7 @@ unsafe fn check_verified_properties(
sqlite3_mprintf(b"SELECT c.addr, LENGTH(ps.verified_key_fingerprint) FROM contacts c LEFT JOIN acpeerstates ps ON c.addr=ps.addr WHERE c.id IN(%s) \x00"
as *const u8 as *const libc::c_char,
to_ids_str);
stmt = dc_sqlite3_prepare((*context).sql, q3);
stmt = dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(), q3);
loop {
if !(sqlite3_step(stmt) == 100i32) {
current_block = 2604890879466389055;
@@ -1935,7 +1948,11 @@ unsafe fn check_verified_properties(
strlen(to_addr) as libc::c_int,
)
.is_null()
&& 0 != dc_apeerstate_load_by_addr(peerstate, (*context).sql, to_addr)
&& 0 != dc_apeerstate_load_by_addr(
peerstate,
&mut context.sql.clone().lock().unwrap(),
to_addr,
)
{
if 0 == is_verified
|| strcmp(
@@ -1960,7 +1977,11 @@ unsafe fn check_verified_properties(
(*peerstate).gossip_key_fingerprint,
2i32,
);
dc_apeerstate_save_to_db(peerstate, (*context).sql, 0i32);
dc_apeerstate_save_to_db(
peerstate,
&mut context.sql.clone().lock().unwrap(),
0i32,
);
is_verified = 1i32
}
}
@@ -2095,7 +2116,7 @@ unsafe fn is_known_rfc724_mid(
let mut is_known: libc::c_int = 0i32;
if !rfc724_mid.is_null() {
let mut stmt: *mut sqlite3_stmt =
dc_sqlite3_prepare((*context).sql,
dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(),
b"SELECT m.id FROM msgs m LEFT JOIN chats c ON m.chat_id=c.id WHERE m.rfc724_mid=? AND m.chat_id>9 AND c.blocked=0;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, rfc724_mid, -1i32, None);
@@ -2184,7 +2205,8 @@ unsafe fn is_msgrmsg_rfc724_mid(
let mut is_msgrmsg: libc::c_int = 0i32;
if !rfc724_mid.is_null() {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM msgs WHERE rfc724_mid=? AND msgrmsg!=0 AND chat_id>9;\x00"
as *const u8 as *const libc::c_char,
);
@@ -2203,8 +2225,7 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list(
mut ids: *mut dc_array_t,
mut check_self: *mut libc::c_int,
) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || adr_list.is_null()
{
if adr_list.is_null() {
return;
}
let mut cur: *mut clistiter = (*(*adr_list).ad_list).first;
@@ -2254,7 +2275,7 @@ unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
mut ids: *mut dc_array_t,
mut check_self: *mut libc::c_int,
) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || mb_list.is_null() {
if mb_list.is_null() {
return;
}
let mut cur: *mut clistiter = (*(*mb_list).mb_list).first;
@@ -2297,13 +2318,13 @@ unsafe fn add_or_lookup_contact_by_addr(
if check_self.is_null() {
check_self = &mut dummy
}
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || addr_spec.is_null()
{
if addr_spec.is_null() {
return;
}
*check_self = 0i32;
let mut self_addr: *mut libc::c_char = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);

317
src/dc_securejoin.rs
View File

@@ -44,91 +44,92 @@ pub unsafe fn dc_get_securejoin_qr(
let mut chat: *mut dc_chat_t = 0 as *mut dc_chat_t;
let mut group_name: *mut libc::c_char = 0 as *mut libc::c_char;
let mut group_name_urlencoded: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
dc_ensure_secret_key_exists(context);
invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id);
if invitenumber.is_null() {
invitenumber = dc_create_id();
dc_token_save(context, DC_TOKEN_INVITENUMBER, group_chat_id, invitenumber);
}
auth = dc_token_lookup(context, DC_TOKEN_AUTH, group_chat_id);
if auth.is_null() {
auth = dc_create_id();
dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, auth);
}
self_addr = dc_sqlite3_get_config(
(*context).sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
dc_ensure_secret_key_exists(context);
invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id);
if invitenumber.is_null() {
invitenumber = dc_create_id();
dc_token_save(context, DC_TOKEN_INVITENUMBER, group_chat_id, invitenumber);
}
auth = dc_token_lookup(context, DC_TOKEN_AUTH, group_chat_id);
if auth.is_null() {
auth = dc_create_id();
dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, auth);
}
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if self_addr.is_null() {
dc_log_error(
context,
0i32,
b"Not configured, cannot generate QR code.\x00" as *const u8 as *const libc::c_char,
);
if self_addr.is_null() {
dc_log_error(
context,
0i32,
b"Not configured, cannot generate QR code.\x00" as *const u8 as *const libc::c_char,
);
} else {
self_name = dc_sqlite3_get_config(
(*context).sql,
b"displayname\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
fingerprint = get_self_fingerprint(context);
if !fingerprint.is_null() {
self_addr_urlencoded = dc_urlencode(self_addr);
self_name_urlencoded = dc_urlencode(self_name);
if 0 != group_chat_id {
chat = dc_get_chat(context, group_chat_id);
if chat.is_null() {
dc_log_error(
context,
0i32,
b"Cannot get QR-code for chat-id %i\x00" as *const u8
as *const libc::c_char,
group_chat_id,
);
current_block = 9531737720721467826;
} else {
group_name = dc_chat_get_name(chat);
group_name_urlencoded = dc_urlencode(group_name);
qr = dc_mprintf(
b"OPENPGP4FPR:%s#a=%s&g=%s&x=%s&i=%s&s=%s\x00" as *const u8
as *const libc::c_char,
fingerprint,
self_addr_urlencoded,
group_name_urlencoded,
(*chat).grpid,
invitenumber,
auth,
);
current_block = 1118134448028020070;
}
} else {
self_name = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"displayname\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
fingerprint = get_self_fingerprint(context);
if !fingerprint.is_null() {
self_addr_urlencoded = dc_urlencode(self_addr);
self_name_urlencoded = dc_urlencode(self_name);
if 0 != group_chat_id {
chat = dc_get_chat(context, group_chat_id);
if chat.is_null() {
dc_log_error(
context,
0i32,
b"Cannot get QR-code for chat-id %i\x00" as *const u8
as *const libc::c_char,
group_chat_id,
);
current_block = 9531737720721467826;
} else {
group_name = dc_chat_get_name(chat);
group_name_urlencoded = dc_urlencode(group_name);
qr = dc_mprintf(
b"OPENPGP4FPR:%s#a=%s&n=%s&i=%s&s=%s\x00" as *const u8
b"OPENPGP4FPR:%s#a=%s&g=%s&x=%s&i=%s&s=%s\x00" as *const u8
as *const libc::c_char,
fingerprint,
self_addr_urlencoded,
self_name_urlencoded,
group_name_urlencoded,
(*chat).grpid,
invitenumber,
auth,
);
current_block = 1118134448028020070;
}
match current_block {
9531737720721467826 => {}
_ => {
dc_log_info(
context,
0i32,
b"Generated QR code: %s\x00" as *const u8 as *const libc::c_char,
qr,
);
}
} else {
qr = dc_mprintf(
b"OPENPGP4FPR:%s#a=%s&n=%s&i=%s&s=%s\x00" as *const u8 as *const libc::c_char,
fingerprint,
self_addr_urlencoded,
self_name_urlencoded,
invitenumber,
auth,
);
current_block = 1118134448028020070;
}
match current_block {
9531737720721467826 => {}
_ => {
dc_log_info(
context,
0i32,
b"Generated QR code: %s\x00" as *const u8 as *const libc::c_char,
qr,
);
}
}
}
}
free(self_addr_urlencoded as *mut libc::c_void);
free(self_addr as *mut libc::c_void);
free(self_name as *mut libc::c_void);
@@ -145,17 +146,26 @@ pub unsafe fn dc_get_securejoin_qr(
dc_strdup(0 as *const libc::c_char)
};
}
unsafe fn get_self_fingerprint(mut context: &dc_context_t) -> *mut libc::c_char {
let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
let mut self_key: *mut dc_key_t = dc_key_new();
let mut fingerprint: *mut libc::c_char = 0 as *mut libc::c_char;
self_addr = dc_sqlite3_get_config(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if !(self_addr.is_null() || 0 == dc_key_load_self_public(self_key, self_addr, (*context).sql)) {
fingerprint = dc_key_get_fingerprint(self_key);
if !(self_addr.is_null()
|| 0 == dc_key_load_self_public(
context,
self_key,
self_addr,
&mut context.sql.clone().lock().unwrap(),
))
{
fingerprint = dc_key_get_fingerprint(context, self_key);
fingerprint.is_null();
}
free(self_addr as *mut libc::c_void);
@@ -175,7 +185,6 @@ pub unsafe fn dc_join_securejoin(
let mut contact_chat_id: uint32_t = 0i32 as uint32_t;
let mut join_vg: libc::c_int = 0i32;
let mut qr_scan: *mut dc_lot_t = 0 as *mut dc_lot_t;
let mut qr_locked: libc::c_int = 0i32;
dc_log_info(
context,
0i32,
@@ -199,16 +208,12 @@ pub unsafe fn dc_join_securejoin(
0i32,
b"Unknown contact.\x00" as *const u8 as *const libc::c_char,
);
} else if !(0 != (*context).shall_stop_ongoing) {
} else if !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
join_vg = ((*qr_scan).state == 202i32) as libc::c_int;
(*context).bobs_status = 0i32;
pthread_mutex_lock(&mut (*context).bobs_qr_critical);
qr_locked = 1i32;
(*context).bobs_qr_scan = qr_scan;
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
}
let bob_a = context.bob.clone();
let mut bob = bob_a.write().unwrap();
bob.status = 0;
bob.qr_scan = qr_scan;
if 0 != fingerprint_equals_sender(context, (*qr_scan).fingerprint, contact_chat_id)
{
dc_log_info(
@@ -216,8 +221,8 @@ pub unsafe fn dc_join_securejoin(
0i32,
b"Taking protocol shortcut.\x00" as *const u8 as *const libc::c_char,
);
(*context).bob_expects = 6i32;
((*context).cb)(
bob.expects = 6;
(context.cb)(
context,
Event::SECUREJOIN_JOINER_PROGRESS,
chat_id_2_contact_id(context, contact_chat_id) as uintptr_t,
@@ -242,7 +247,7 @@ pub unsafe fn dc_join_securejoin(
);
free(own_fingerprint as *mut libc::c_void);
} else {
(*context).bob_expects = 2i32;
bob.expects = 2;
send_handshake_msg(
context,
contact_chat_id,
@@ -257,14 +262,17 @@ pub unsafe fn dc_join_securejoin(
);
}
// Bob -> Alice
while !(0 != (*context).shall_stop_ongoing) {
while !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
usleep((300i32 * 1000i32) as useconds_t);
}
}
}
}
(*context).bob_expects = 0i32;
if (*context).bobs_status == 1i32 {
let bob_a = context.bob.clone();
let mut bob = bob_a.write().unwrap();
bob.expects = 0;
if bob.status == 1 {
if 0 != join_vg {
ret_chat_id = dc_get_chat_id_by_grpid(
context,
@@ -276,19 +284,15 @@ pub unsafe fn dc_join_securejoin(
ret_chat_id = contact_chat_id as libc::c_int
}
}
pthread_mutex_lock(&mut (*context).bobs_qr_critical);
qr_locked = 1i32;
(*context).bobs_qr_scan = 0 as *mut dc_lot_t;
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
}
bob.qr_scan = std::ptr::null_mut();
dc_lot_unref(qr_scan);
if 0 != ongoing_allocated {
dc_free_ongoing(context);
}
return ret_chat_id as uint32_t;
ret_chat_id as uint32_t
}
unsafe fn send_handshake_msg(
mut context: &dc_context_t,
mut contact_chat_id: uint32_t,
@@ -351,10 +355,14 @@ unsafe fn fingerprint_equals_sender(
if !(0
== dc_contact_load_from_db(
contact,
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
dc_array_get_id(contacts, 0i32 as size_t),
)
|| 0 == dc_apeerstate_load_by_addr(peerstate, (*context).sql, (*contact).addr))
|| 0 == dc_apeerstate_load_by_addr(
peerstate,
&mut context.sql.clone().lock().unwrap(),
(*contact).addr,
))
{
fingerprint_normalized = dc_normalize_fingerprint(fingerprint);
if strcasecmp(fingerprint_normalized, (*peerstate).public_key_fingerprint) == 0i32 {
@@ -369,12 +377,11 @@ unsafe fn fingerprint_equals_sender(
}
/* library private: secure-join */
pub unsafe fn dc_handle_securejoin_handshake(
mut context: &dc_context_t,
mut mimeparser: *mut dc_mimeparser_t,
mut contact_id: uint32_t,
context: &dc_context_t,
mimeparser: *mut dc_mimeparser_t,
contact_id: uint32_t,
) -> libc::c_int {
let mut current_block: u64;
let mut qr_locked: libc::c_int = 0i32;
let mut step: *const libc::c_char = 0 as *const libc::c_char;
let mut join_vg: libc::c_int = 0i32;
let mut scanned_fingerprint_of_alice: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -385,7 +392,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
let mut grpid: *mut libc::c_char = 0 as *mut libc::c_char;
let mut ret: libc::c_int = 0i32;
let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t;
if !(context.is_null() || mimeparser.is_null() || contact_id <= 9i32 as libc::c_uint) {
if !(mimeparser.is_null() || contact_id <= 9i32 as libc::c_uint) {
step = lookup_field(
mimeparser,
b"Secure-Join\x00" as *const u8 as *const libc::c_char,
@@ -449,7 +456,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
0i32,
b"Secure-join requested.\x00" as *const u8 as *const libc::c_char,
);
((*context).cb)(
(context.cb)(
context,
Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t,
@@ -478,11 +485,10 @@ pub unsafe fn dc_handle_securejoin_handshake(
b"vc-auth-required\x00" as *const u8 as *const libc::c_char,
) == 0i32
{
pthread_mutex_lock(&mut (*context).bobs_qr_critical);
qr_locked = 1i32;
if (*context).bobs_qr_scan.is_null()
|| (*context).bob_expects != 2i32
|| 0 != join_vg && (*(*context).bobs_qr_scan).state != 202i32
let bob_a = context.bob.clone();
let bob = bob_a.read().unwrap();
let scan = bob.qr_scan;
if scan.is_null() || bob.expects != 2i32 || 0 != join_vg && (*scan).state != 202i32
{
dc_log_warning(
context,
@@ -493,15 +499,10 @@ pub unsafe fn dc_handle_securejoin_handshake(
// no error, just aborted somehow or a mail from another handshake
current_block = 4378276786830486580;
} else {
scanned_fingerprint_of_alice =
dc_strdup((*(*context).bobs_qr_scan).fingerprint);
auth = dc_strdup((*(*context).bobs_qr_scan).auth);
scanned_fingerprint_of_alice = dc_strdup((*scan).fingerprint);
auth = dc_strdup((*scan).auth);
if 0 != join_vg {
grpid = dc_strdup((*(*context).bobs_qr_scan).text2)
}
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
grpid = dc_strdup((*scan).text2)
}
if 0 == encrypted_and_signed(mimeparser, scanned_fingerprint_of_alice) {
could_not_establish_secure_connection(
@@ -537,13 +538,14 @@ pub unsafe fn dc_handle_securejoin_handshake(
b"Fingerprint verified.\x00" as *const u8 as *const libc::c_char,
);
own_fingerprint = get_self_fingerprint(context);
((*context).cb)(
(context.cb)(
context,
Event::SECUREJOIN_JOINER_PROGRESS,
contact_id as uintptr_t,
400i32 as uintptr_t,
);
(*context).bob_expects = 6i32;
context.bob.clone().write().unwrap().expects = 6;
send_handshake_msg(
context,
contact_chat_id,
@@ -643,13 +645,13 @@ pub unsafe fn dc_handle_securejoin_handshake(
b"Auth verified.\x00" as *const u8 as *const libc::c_char,
);
secure_connection_established(context, contact_chat_id);
((*context).cb)(
(context.cb)(
context,
Event::CONTACTS_CHANGED,
contact_id as uintptr_t,
0i32 as uintptr_t,
);
((*context).cb)(
(context.cb)(
context,
Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t,
@@ -692,7 +694,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
0 as *const libc::c_char,
0 as *const libc::c_char,
);
((*context).cb)(
(context.cb)(
context,
Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t,
@@ -714,7 +716,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
if 0 != join_vg {
ret = 0x1i32
}
if (*context).bob_expects != 6i32 {
if context.bob.clone().read().unwrap().expects != 6 {
dc_log_info(
context,
0i32,
@@ -723,11 +725,8 @@ pub unsafe fn dc_handle_securejoin_handshake(
);
current_block = 4378276786830486580;
} else {
pthread_mutex_lock(&mut (*context).bobs_qr_critical);
qr_locked = 1i32;
if (*context).bobs_qr_scan.is_null()
|| 0 != join_vg && (*(*context).bobs_qr_scan).state != 202i32
{
let scan = context.bob.clone().read().unwrap().qr_scan;
if scan.is_null() || 0 != join_vg && (*scan).state != 202i32 {
dc_log_warning(
context,
0i32,
@@ -736,14 +735,9 @@ pub unsafe fn dc_handle_securejoin_handshake(
);
current_block = 4378276786830486580;
} else {
scanned_fingerprint_of_alice =
dc_strdup((*(*context).bobs_qr_scan).fingerprint);
scanned_fingerprint_of_alice = dc_strdup((*scan).fingerprint);
if 0 != join_vg {
grpid = dc_strdup((*(*context).bobs_qr_scan).text2)
}
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
grpid = dc_strdup((*scan).text2)
}
let mut vg_expect_encrypted: libc::c_int = 1i32;
if 0 != join_vg {
@@ -788,7 +782,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
current_block = 4378276786830486580;
} else {
dc_scaleup_contact_origin(context, contact_id, 0x2000000i32);
((*context).cb)(
(context.cb)(
context,
Event::CONTACTS_CHANGED,
0i32 as uintptr_t,
@@ -818,7 +812,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
4378276786830486580 => {}
_ => {
secure_connection_established(context, contact_chat_id);
(*context).bob_expects = 0i32;
context.bob.clone().write().unwrap().expects = 0;
if 0 != join_vg {
send_handshake_msg(
context,
@@ -858,13 +852,13 @@ pub unsafe fn dc_handle_securejoin_handshake(
);
current_block = 4378276786830486580;
} else {
((*context).cb)(
(context.cb)(
context,
Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t,
800i32 as uintptr_t,
);
((*context).cb)(
(context.cb)(
context,
Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t,
@@ -885,10 +879,6 @@ pub unsafe fn dc_handle_securejoin_handshake(
}
}
}
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
}
dc_contact_unref(contact);
free(scanned_fingerprint_of_alice as *mut libc::c_void);
free(auth as *mut libc::c_void);
@@ -896,8 +886,8 @@ pub unsafe fn dc_handle_securejoin_handshake(
free(grpid as *mut libc::c_void);
return ret;
}
unsafe fn end_bobs_joining(mut context: &dc_context_t, mut status: libc::c_int) {
(*context).bobs_status = status;
unsafe fn end_bobs_joining(context: &dc_context_t, status: libc::c_int) {
context.bob.clone().write().unwrap().status = status;
dc_stop_ongoing_process(context);
}
unsafe fn secure_connection_established(mut context: &dc_context_t, mut contact_chat_id: uint32_t) {
@@ -913,7 +903,7 @@ unsafe fn secure_connection_established(mut context: &dc_context_t, mut contact_
},
);
dc_add_device_msg(context, contact_chat_id, msg);
((*context).cb)(
(context.cb)(
context,
Event::CHAT_MODIFIED,
contact_chat_id as uintptr_t,
@@ -941,12 +931,12 @@ unsafe fn lookup_field(
return value;
}
unsafe fn could_not_establish_secure_connection(
mut context: *mut dc_context_t,
mut contact_chat_id: uint32_t,
mut details: *const libc::c_char,
context: &dc_context_t,
contact_chat_id: uint32_t,
details: *const libc::c_char,
) {
let mut contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id);
let mut contact: &dc_contact_t = dc_get_contact(context, contact_id);
let mut contact = dc_get_contact(context, contact_id);
let mut msg: *mut libc::c_char = dc_stock_str_repl_string(
context,
36i32,
@@ -968,16 +958,22 @@ unsafe fn could_not_establish_secure_connection(
dc_contact_unref(contact);
}
unsafe fn mark_peer_as_verified(
mut context: *mut dc_context_t,
mut fingerprint: *const libc::c_char,
context: &dc_context_t,
fingerprint: *const libc::c_char,
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut peerstate: &dc_apeerstate_t = dc_apeerstate_new(context);
if !(0 == dc_apeerstate_load_by_fingerprint(peerstate, (*context).sql, fingerprint)) {
let mut peerstate = dc_apeerstate_new(context);
if !(0
== dc_apeerstate_load_by_fingerprint(
peerstate,
&mut context.sql.clone().lock().unwrap(),
fingerprint,
))
{
if !(0 == dc_apeerstate_set_verified(peerstate, 1i32, fingerprint, 2i32)) {
(*peerstate).prefer_encrypt = 1i32;
(*peerstate).to_save |= 0x2i32;
dc_apeerstate_save_to_db(peerstate, (*context).sql, 0i32);
dc_apeerstate_save_to_db(peerstate, &mut context.sql.clone().lock().unwrap(), 0i32);
success = 1i32
}
}
@@ -1037,10 +1033,10 @@ pub unsafe fn dc_handle_degrade_event(
mut context: &dc_context_t,
mut peerstate: *mut dc_apeerstate_t,
) {
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut stmt = 0 as *mut sqlite3_stmt;
let mut contact_id: uint32_t = 0i32 as uint32_t;
let mut contact_chat_id: uint32_t = 0i32 as uint32_t;
if !(context.is_null() || peerstate.is_null()) {
if !peerstate.is_null() {
// - we do not issue an warning for DC_DE_ENCRYPTION_PAUSED as this is quite normal
// - currently, we do not issue an extra warning for DC_DE_VERIFICATION_LOST - this always comes
// together with DC_DE_FINGERPRINT_CHANGED which is logged, the idea is not to bother
@@ -1048,7 +1044,8 @@ pub unsafe fn dc_handle_degrade_event(
// (and he will know this and can fix this)
if 0 != (*peerstate).degrade_event & 0x2i32 {
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM contacts WHERE addr=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_text(stmt, 1i32, (*peerstate).addr, -1i32, None);
@@ -1067,7 +1064,7 @@ pub unsafe fn dc_handle_degrade_event(
dc_stock_str_repl_string(context, 37i32, (*peerstate).addr);
dc_add_device_msg(context, contact_chat_id, msg);
free(msg as *mut libc::c_void);
((*context).cb)(
(context.cb)(
context,
Event::CHAT_MODIFIED,
contact_chat_id as uintptr_t,

64
src/dc_smtp.rs
View File

@@ -16,8 +16,6 @@ pub struct dc_smtp_t {
pub from: *mut libc::c_char,
pub esmtp: libc::c_int,
pub log_connect_errors: libc::c_int,
// TODO: Remvoe
pub context: *mut dc_context_t,
pub error: *mut libc::c_char,
pub error_etpan: libc::c_int,
}
@@ -28,7 +26,6 @@ pub fn dc_smtp_new() -> dc_smtp_t {
from: std::ptr::null_mut(),
esmtp: 0,
log_connect_errors: 1,
context: std::ptr::null_mut(),
error: std::ptr::null_mut(),
error_etpan: 0,
}
@@ -38,7 +35,6 @@ pub unsafe fn dc_smtp_unref(smtp: &mut dc_smtp_t) {
dc_smtp_disconnect(smtp);
free(smtp.from as *mut libc::c_void);
free(smtp.error as *mut libc::c_void);
free(smtp as *mut libc::c_void);
}
pub unsafe fn dc_smtp_disconnect(smtp: &mut dc_smtp_t) {
@@ -56,7 +52,11 @@ pub unsafe fn dc_smtp_is_connected(smtp: &dc_smtp_t) -> libc::c_int {
}
}
pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t) -> libc::c_int {
pub unsafe fn dc_smtp_connect(
context: &dc_context_t,
smtp: &mut dc_smtp_t,
lp: *const dc_loginparam_t,
) -> libc::c_int {
let mut current_block: u64;
let mut success: libc::c_int = 0;
let mut r: libc::c_int = 0;
@@ -67,14 +67,14 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
if !smtp.etpan.is_null() {
dc_log_warning(
smtp.context,
context,
0,
b"SMTP already connected.\x00" as *const u8 as *const libc::c_char,
);
success = 1;
} else if (*lp).addr.is_null() || (*lp).send_server.is_null() || (*lp).send_port == 0 {
dc_log_event_seq(
smtp.context,
context,
Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP bad parameters.\x00" as *const u8 as *const libc::c_char,
@@ -85,7 +85,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
smtp.etpan = mailsmtp_new(0 as size_t, None);
if smtp.etpan.is_null() {
dc_log_error(
smtp.context,
context,
0,
b"SMTP-object creation failed.\x00" as *const u8 as *const libc::c_char,
);
@@ -94,7 +94,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
mailsmtp_set_progress_callback(
smtp.etpan,
Some(body_progress),
smtp as *mut libc::c_void,
smtp as *mut _ as *mut libc::c_void,
);
/* connect to SMTP server */
if 0 != (*lp).server_flags & (0x10000 | 0x40000) {
@@ -105,7 +105,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
);
if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq(
smtp.context,
context,
Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-Socket connection to %s:%i failed (%s)\x00" as *const u8
@@ -126,7 +126,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
);
if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq(
smtp.context,
context,
Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-SSL connection to %s:%i failed (%s)\x00" as *const u8
@@ -155,7 +155,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
}
if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq(
smtp.context,
context,
Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-helo failed (%s)\x00" as *const u8 as *const libc::c_char,
@@ -166,7 +166,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
r = mailsmtp_socket_starttls(smtp.etpan);
if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq(
smtp.context,
context,
Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-STARTTLS failed (%s)\x00" as *const u8
@@ -188,7 +188,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
}
if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq(
smtp.context,
context,
Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-helo failed (%s)\x00" as *const u8
@@ -198,7 +198,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
current_block = 12512295087047028901;
} else {
dc_log_info(
smtp.context,
context,
0,
b"SMTP-server %s:%i STARTTLS-connected.\x00" as *const u8
as *const libc::c_char,
@@ -211,7 +211,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
} else {
if 0 != (*lp).server_flags & 0x40000 {
dc_log_info(
smtp.context,
context,
0,
b"SMTP-server %s:%i connected.\x00" as *const u8
as *const libc::c_char,
@@ -220,7 +220,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
);
} else {
dc_log_info(
smtp.context,
context,
0,
b"SMTP-server %s:%i SSL-connected.\x00" as *const u8
as *const libc::c_char,
@@ -236,14 +236,14 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
if !(*lp).send_user.is_null() {
if 0 != (*lp).server_flags & 0x2 {
dc_log_info(
smtp.context,
context,
0,
b"SMTP-OAuth2 connect...\x00" as *const u8
as *const libc::c_char,
);
let mut access_token: *mut libc::c_char =
dc_get_oauth2_access_token(
smtp.context,
context,
(*lp).addr,
(*lp).send_pw,
0,
@@ -256,7 +256,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
if r != MAILSMTP_NO_ERROR as libc::c_int {
free(access_token as *mut libc::c_void);
access_token = dc_get_oauth2_access_token(
smtp.context,
context,
(*lp).addr,
(*lp).send_pw,
0x1,
@@ -284,7 +284,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
& MAILSMTP_AUTH_PLAIN as libc::c_int
{
dc_log_info(
smtp.context,
context,
0,
b"Trying SMTP-Login workaround \"%s\"...\x00"
as *const u8
@@ -299,7 +299,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
);
if err < 0 {
dc_log_error(
smtp.context,
context,
0,
b"SMTP-Login: Cannot get hostname.\x00"
as *const u8
@@ -333,7 +333,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
_ => {
if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq(
smtp.context,
context,
Event::ERROR_NETWORK,
&mut smtp.log_connect_errors
as *mut libc::c_int,
@@ -346,7 +346,7 @@ pub unsafe fn dc_smtp_connect(smtp: &mut dc_smtp_t, lp: *const dc_loginparam_t)
current_block = 12512295087047028901;
} else {
dc_log_event(
smtp.context,
context,
Event::SMTP_CONNECTED,
0,
b"SMTP-login as %s ok.\x00" as *const u8
@@ -388,6 +388,7 @@ unsafe extern "C" fn body_progress(
}
pub unsafe fn dc_smtp_send_msg(
context: &dc_context_t,
smtp: &mut dc_smtp_t,
recipients: *const clist,
data_not_terminated: *const libc::c_char,
@@ -418,6 +419,7 @@ pub unsafe fn dc_smtp_send_msg(
};
if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error(
context,
smtp,
b"SMTP failed to start message\x00" as *const u8 as *const libc::c_char,
r,
@@ -444,6 +446,7 @@ pub unsafe fn dc_smtp_send_msg(
};
if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error(
context,
smtp,
b"SMTP failed to add recipient\x00" as *const u8 as *const libc::c_char,
r,
@@ -465,6 +468,7 @@ pub unsafe fn dc_smtp_send_msg(
r = mailsmtp_data(smtp.etpan);
if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error(
context,
smtp,
b"SMTP failed to set data\x00" as *const u8 as *const libc::c_char,
r,
@@ -473,6 +477,7 @@ pub unsafe fn dc_smtp_send_msg(
r = mailsmtp_data_message(smtp.etpan, data_not_terminated, data_bytes);
if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error(
context,
smtp,
b"SMTP failed to send message\x00" as *const u8
as *const libc::c_char,
@@ -480,7 +485,7 @@ pub unsafe fn dc_smtp_send_msg(
);
} else {
dc_log_event(
smtp.context,
context,
Event::SMTP_MESSAGE_SENT,
0,
b"Message was sent to SMTP server\x00" as *const u8
@@ -497,7 +502,12 @@ pub unsafe fn dc_smtp_send_msg(
success
}
unsafe fn log_error(smtp: &mut dc_smtp_t, what_failed: *const libc::c_char, r: libc::c_int) {
unsafe fn log_error(
context: &dc_context_t,
smtp: &mut dc_smtp_t,
what_failed: *const libc::c_char,
r: libc::c_int,
) {
let mut error_msg: *mut libc::c_char = dc_mprintf(
b"%s: %s: %s\x00" as *const u8 as *const libc::c_char,
what_failed,
@@ -505,7 +515,7 @@ unsafe fn log_error(smtp: &mut dc_smtp_t, what_failed: *const libc::c_char, r: l
(*smtp.etpan).response,
);
dc_log_warning(
smtp.context,
context,
0,
b"%s\x00" as *const u8 as *const libc::c_char,
error_msg,

186
src/dc_sqlite3.rs
View File

@@ -73,13 +73,12 @@ pub unsafe fn dc_sqlite3_open(
dbfile,
&mut sql.cobj,
SQLITE_OPEN_FULLMUTEX
| (if flags & DC_OPEN_READONLY {
| (if 0 != (flags & DC_OPEN_READONLY as i32) {
SQLITE_OPEN_READONLY
} else {
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
}),
std::ptr::null(),
0 as *const libc::c_char,
) != 0
{
dc_sqlite3_log_error(
@@ -90,15 +89,17 @@ pub unsafe fn dc_sqlite3_open(
);
} else {
dc_sqlite3_execute(
context,
sql,
b"PRAGMA secure_delete=on;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_busy_timeout(sql.cobj, 10 * 1000);
if 0 == flags & DC_OPEN_READONLY {
if 0 == flags & DC_OPEN_READONLY as i32 {
let mut exists_before_update = 0;
let mut dbversion_before_update = 0;
/* Init tables to dbversion=0 */
if 0 == dc_sqlite3_table_exists(
context,
sql,
b"config\x00" as *const u8 as *const libc::c_char,
) {
@@ -110,17 +111,20 @@ pub unsafe fn dc_sqlite3_open(
dbfile,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE config (id INTEGER PRIMARY KEY, keyname TEXT, value TEXT);\x00"
as *const u8 as
*const libc::c_char
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX config_index1 ON config (keyname);\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE contacts (\
id INTEGER PRIMARY KEY AUTOINCREMENT, \
@@ -133,16 +137,19 @@ pub unsafe fn dc_sqlite3_open(
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX contacts_index1 ON contacts (name COLLATE NOCASE);\x00"
as *const u8 as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX contacts_index2 ON contacts (addr COLLATE NOCASE);\x00"
as *const u8 as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"INSERT INTO contacts (id,name,origin) VALUES \
(1,\'self\',262144), (2,\'device\',262144), (3,\'rsvd\',262144), \
@@ -151,6 +158,7 @@ pub unsafe fn dc_sqlite3_open(
as *const u8 as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE chats (\
id INTEGER PRIMARY KEY AUTOINCREMENT, \
@@ -164,21 +172,25 @@ pub unsafe fn dc_sqlite3_open(
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX chats_index1 ON chats (grpid);\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE chats_contacts (chat_id INTEGER, contact_id INTEGER);\x00"
as *const u8 as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX chats_contacts_index1 ON chats_contacts (chat_id);\x00"
as *const u8 as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"INSERT INTO chats (id,type,name) VALUES \
(1,120,\'deaddrop\'), (2,120,\'rsvd\'), (3,120,\'trash\'), \
@@ -187,6 +199,7 @@ pub unsafe fn dc_sqlite3_open(
as *const u8 as *const libc::c_char
);
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE msgs (\
id INTEGER PRIMARY KEY AUTOINCREMENT, \
@@ -207,26 +220,31 @@ pub unsafe fn dc_sqlite3_open(
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX msgs_index1 ON msgs (rfc724_mid);\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX msgs_index2 ON msgs (chat_id);\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX msgs_index3 ON msgs (timestamp);\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX msgs_index4 ON msgs (state);\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"INSERT INTO msgs (id,msgrmsg,txt) VALUES \
(1,0,\'marker1\'), (2,0,\'rsvd\'), (3,0,\'rsvd\'), \
@@ -235,6 +253,7 @@ pub unsafe fn dc_sqlite3_open(
as *const u8 as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE jobs (\
id INTEGER PRIMARY KEY AUTOINCREMENT, \
@@ -246,36 +265,44 @@ pub unsafe fn dc_sqlite3_open(
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX jobs_index1 ON jobs (desired_timestamp);\x00" as *const u8
as *const libc::c_char,
);
if 0 == dc_sqlite3_table_exists(
context,
sql,
b"config\x00" as *const u8 as *const libc::c_char,
) || 0
== dc_sqlite3_table_exists(
context,
sql,
b"contacts\x00" as *const u8 as *const libc::c_char,
)
|| 0 == dc_sqlite3_table_exists(
context,
sql,
b"chats\x00" as *const u8 as *const libc::c_char,
)
|| 0 == dc_sqlite3_table_exists(
context,
sql,
b"chats_contacts\x00" as *const u8 as *const libc::c_char,
)
|| 0 == dc_sqlite3_table_exists(
context,
sql,
b"msgs\x00" as *const u8 as *const libc::c_char,
)
|| 0 == dc_sqlite3_table_exists(
context,
sql,
b"jobs\x00" as *const u8 as *const libc::c_char,
)
{
dc_sqlite3_log_error(
context,
sql,
b"Cannot create tables in new database \"%s\".\x00" as *const u8
as *const libc::c_char,
@@ -285,6 +312,7 @@ pub unsafe fn dc_sqlite3_open(
current_block = 13628706266672894061;
} else {
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
0,
@@ -294,6 +322,7 @@ pub unsafe fn dc_sqlite3_open(
} else {
exists_before_update = 1;
dbversion_before_update = dc_sqlite3_get_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
0,
@@ -312,11 +341,12 @@ pub unsafe fn dc_sqlite3_open(
let mut update_file_paths: libc::c_int = 0;
if dbversion < 1 {
dc_sqlite3_execute(
sql,
context, sql,
b"CREATE TABLE leftgrps ( id INTEGER PRIMARY KEY, grpid TEXT DEFAULT \'\');\x00"
as *const u8 as *const libc::c_char
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX leftgrps_index1 ON leftgrps (grpid);\x00"
as *const u8
@@ -324,6 +354,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 1;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
1,
@@ -331,6 +362,7 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 2 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE contacts ADD COLUMN authname TEXT DEFAULT \'\';\x00"
as *const u8
@@ -338,6 +370,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 2;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
2,
@@ -345,6 +378,7 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 7 {
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE keypairs (\
id INTEGER PRIMARY KEY, \
@@ -358,6 +392,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 7;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
7,
@@ -365,6 +400,7 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 10 {
dc_sqlite3_execute(
context,
sql,
b"CREATE TABLE acpeerstates (\
id INTEGER PRIMARY KEY, \
@@ -377,6 +413,7 @@ pub unsafe fn dc_sqlite3_open(
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX acpeerstates_index1 ON acpeerstates (addr);\x00"
as *const u8
@@ -384,6 +421,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 10;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
10,
@@ -391,11 +429,12 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 12 {
dc_sqlite3_execute(
sql,
context, sql,
b"CREATE TABLE msgs_mdns ( msg_id INTEGER, contact_id INTEGER);\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX msgs_mdns_index1 ON msgs_mdns (msg_id);\x00"
as *const u8
@@ -403,6 +442,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 12;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
12,
@@ -410,29 +450,34 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 17 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE chats ADD COLUMN archived INTEGER DEFAULT 0;\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX chats_index2 ON chats (archived);\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN starred INTEGER DEFAULT 0;\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX msgs_index5 ON msgs (starred);\x00" as *const u8
as *const libc::c_char,
);
dbversion = 17;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
17,
@@ -440,17 +485,19 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 18 {
dc_sqlite3_execute(
sql,
context, sql,
b"ALTER TABLE acpeerstates ADD COLUMN gossip_timestamp INTEGER DEFAULT 0;\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE acpeerstates ADD COLUMN gossip_key;\x00" as *const u8
as *const libc::c_char,
);
dbversion = 18;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
18,
@@ -458,23 +505,26 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 27 {
dc_sqlite3_execute(
context,
sql,
b"DELETE FROM msgs WHERE chat_id=1 OR chat_id=2;\x00" as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
sql,
context, sql,
b"CREATE INDEX chats_contacts_index2 ON chats_contacts (contact_id);\x00"
as *const u8 as
*const libc::c_char
);
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN timestamp_sent INTEGER DEFAULT 0;\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN timestamp_rcvd INTEGER DEFAULT 0;\x00"
as *const u8
@@ -482,6 +532,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 27;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
27,
@@ -489,40 +540,42 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 34 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN hidden INTEGER DEFAULT 0;\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
sql,
context, sql,
b"ALTER TABLE msgs_mdns ADD COLUMN timestamp_sent INTEGER DEFAULT 0;\x00"
as *const u8 as
*const libc::c_char
);
dc_sqlite3_execute(
sql,
context, sql,
b"ALTER TABLE acpeerstates ADD COLUMN public_key_fingerprint TEXT DEFAULT \'\';\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
sql,
context, sql,
b"ALTER TABLE acpeerstates ADD COLUMN gossip_key_fingerprint TEXT DEFAULT \'\';\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
sql,
context, sql,
b"CREATE INDEX acpeerstates_index3 ON acpeerstates (public_key_fingerprint);\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
sql,
context, sql,
b"CREATE INDEX acpeerstates_index4 ON acpeerstates (gossip_key_fingerprint);\x00"
as *const u8 as
*const libc::c_char);
recalc_fingerprints = 1;
dbversion = 34;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
34,
@@ -530,40 +583,42 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 39 {
dc_sqlite3_execute(
sql,
context, sql,
b"CREATE TABLE tokens ( id INTEGER PRIMARY KEY, namespc INTEGER DEFAULT 0, foreign_id INTEGER DEFAULT 0, token TEXT DEFAULT \'\', timestamp INTEGER DEFAULT 0);\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE acpeerstates ADD COLUMN verified_key;\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
sql,
context, sql,
b"ALTER TABLE acpeerstates ADD COLUMN verified_key_fingerprint TEXT DEFAULT \'\';\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
sql,
context, sql,
b"CREATE INDEX acpeerstates_index5 ON acpeerstates (verified_key_fingerprint);\x00"
as *const u8 as
*const libc::c_char);
if dbversion_before_update == 34 {
dc_sqlite3_execute(
sql,
context, sql,
b"UPDATE acpeerstates SET verified_key=gossip_key, verified_key_fingerprint=gossip_key_fingerprint WHERE gossip_key_verified=2;\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
sql,
context, sql,
b"UPDATE acpeerstates SET verified_key=public_key, verified_key_fingerprint=public_key_fingerprint WHERE public_key_verified=2;\x00"
as *const u8 as
*const libc::c_char);
}
dbversion = 39;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
39,
@@ -571,6 +626,7 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 40 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE jobs ADD COLUMN thread INTEGER DEFAULT 0;\x00"
as *const u8
@@ -578,6 +634,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 40;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
40,
@@ -587,6 +644,7 @@ pub unsafe fn dc_sqlite3_open(
update_file_paths = 1;
dbversion = 41;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
41,
@@ -594,12 +652,14 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 42 {
dc_sqlite3_execute(
context,
sql,
b"UPDATE msgs SET txt=\'\' WHERE type!=10\x00" as *const u8
as *const libc::c_char,
);
dbversion = 42;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
42,
@@ -607,12 +667,14 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 44 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN mime_headers TEXT;\x00" as *const u8
as *const libc::c_char,
);
dbversion = 44;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
44,
@@ -620,12 +682,14 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 46 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN mime_in_reply_to TEXT;\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN mime_references TEXT;\x00"
as *const u8
@@ -633,6 +697,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 46;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
46,
@@ -640,6 +705,7 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 47 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE jobs ADD COLUMN tries INTEGER DEFAULT 0;\x00"
as *const u8
@@ -647,6 +713,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 47;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
47,
@@ -654,6 +721,7 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 48 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN move_state INTEGER DEFAULT 1;\x00"
as *const u8
@@ -721,6 +789,7 @@ pub unsafe fn dc_sqlite3_open(
};
dbversion = 48;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
48,
@@ -728,12 +797,13 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 49 {
dc_sqlite3_execute(
sql,
context, sql,
b"ALTER TABLE chats ADD COLUMN gossiped_timestamp INTEGER DEFAULT 0;\x00"
as *const u8 as
*const libc::c_char);
dbversion = 49;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
49,
@@ -742,6 +812,7 @@ pub unsafe fn dc_sqlite3_open(
if dbversion < 50 {
if 0 != exists_before_update {
dc_sqlite3_set_config_int(
context,
sql,
b"show_emails\x00" as *const u8 as *const libc::c_char,
2,
@@ -749,41 +820,45 @@ pub unsafe fn dc_sqlite3_open(
}
dbversion = 50;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
50,
);
}
if dbversion < 53 {
dc_sqlite3_execute(sql,
dc_sqlite3_execute(context, sql,
b"CREATE TABLE locations ( id INTEGER PRIMARY KEY AUTOINCREMENT, latitude REAL DEFAULT 0.0, longitude REAL DEFAULT 0.0, accuracy REAL DEFAULT 0.0, timestamp INTEGER DEFAULT 0, chat_id INTEGER DEFAULT 0, from_id INTEGER DEFAULT 0);\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX locations_index1 ON locations (from_id);\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX locations_index2 ON locations (timestamp);\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(sql,
dc_sqlite3_execute(context, sql,
b"ALTER TABLE chats ADD COLUMN locations_send_begin INTEGER DEFAULT 0;\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(sql,
dc_sqlite3_execute(context, sql,
b"ALTER TABLE chats ADD COLUMN locations_send_until INTEGER DEFAULT 0;\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(sql,
dc_sqlite3_execute(context, sql,
b"ALTER TABLE chats ADD COLUMN locations_last_sent INTEGER DEFAULT 0;\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX chats_index3 ON chats (locations_send_until);\x00"
as *const u8
@@ -791,6 +866,7 @@ pub unsafe fn dc_sqlite3_open(
);
dbversion = 53;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
53,
@@ -798,18 +874,21 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 54 {
dc_sqlite3_execute(
context,
sql,
b"ALTER TABLE msgs ADD COLUMN location_id INTEGER DEFAULT 0;\x00"
as *const u8
as *const libc::c_char,
);
dc_sqlite3_execute(
context,
sql,
b"CREATE INDEX msgs_index6 ON msgs (location_id);\x00" as *const u8
as *const libc::c_char,
);
dbversion = 54;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
54,
@@ -817,12 +896,13 @@ pub unsafe fn dc_sqlite3_open(
}
if dbversion < 55 {
dc_sqlite3_execute(
sql,
context, sql,
b"ALTER TABLE locations ADD COLUMN independent INTEGER DEFAULT 0;\x00" as *const u8 as *const libc::c_char
);
dbversion = 55;
dc_sqlite3_set_config_int(
context,
sql,
b"dbversion\x00" as *const u8 as *const libc::c_char,
55,
@@ -831,13 +911,14 @@ pub unsafe fn dc_sqlite3_open(
if 0 != recalc_fingerprints {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
sql,
b"SELECT addr FROM acpeerstates;\x00" as *const u8
as *const libc::c_char,
);
while sqlite3_step(stmt) == 100 {
let mut peerstate: *mut dc_apeerstate_t =
dc_apeerstate_new(sql.context);
dc_apeerstate_new(context);
if 0 != dc_apeerstate_load_by_addr(
peerstate,
sql,
@@ -852,9 +933,10 @@ pub unsafe fn dc_sqlite3_open(
}
if 0 != update_file_paths {
let mut repl_from: *mut libc::c_char = dc_sqlite3_get_config(
context,
sql,
b"backup_for\x00" as *const u8 as *const libc::c_char,
(*sql.context).blobdir,
context.blobdir,
);
dc_ensure_no_slash(repl_from);
if 0 != !('f' as i32 == 'f' as i32) as libc::c_int as libc::c_long {
@@ -874,7 +956,7 @@ pub unsafe fn dc_sqlite3_open(
as *const u8 as
*const libc::c_char,
repl_from);
dc_sqlite3_execute(sql, q3);
dc_sqlite3_execute(context, sql, q3);
sqlite3_free(q3 as *mut libc::c_void);
if 0 != !('i' as i32 == 'i' as i32) as libc::c_int as libc::c_long {
__assert_rtn(
@@ -894,10 +976,11 @@ pub unsafe fn dc_sqlite3_open(
as *const u8 as
*const libc::c_char,
repl_from);
dc_sqlite3_execute(sql, q3);
dc_sqlite3_execute(context, sql, q3);
sqlite3_free(q3 as *mut libc::c_void);
free(repl_from as *mut libc::c_void);
dc_sqlite3_set_config(
context,
sql,
b"backup_for\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
@@ -913,7 +996,7 @@ pub unsafe fn dc_sqlite3_open(
13628706266672894061 => {}
_ => {
dc_log_info(
sql.context,
context,
0,
b"Opened \"%s\".\x00" as *const u8 as *const libc::c_char,
dbfile,
@@ -924,7 +1007,7 @@ pub unsafe fn dc_sqlite3_open(
}
}
dc_sqlite3_close(sql);
dc_sqlite3_close(context, sql);
0
}
@@ -955,6 +1038,7 @@ pub unsafe fn dc_sqlite3_set_config(
}
if !value.is_null() {
stmt = dc_sqlite3_prepare(
context,
sql,
b"SELECT value FROM config WHERE keyname=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -963,6 +1047,7 @@ pub unsafe fn dc_sqlite3_set_config(
sqlite3_finalize(stmt);
if state == 101 {
stmt = dc_sqlite3_prepare(
context,
sql,
b"INSERT INTO config (keyname, value) VALUES (?, ?);\x00" as *const u8
as *const libc::c_char,
@@ -973,6 +1058,7 @@ pub unsafe fn dc_sqlite3_set_config(
sqlite3_finalize(stmt);
} else if state == 100 {
stmt = dc_sqlite3_prepare(
context,
sql,
b"UPDATE config SET value=? WHERE keyname=?;\x00" as *const u8
as *const libc::c_char,
@@ -992,6 +1078,7 @@ pub unsafe fn dc_sqlite3_set_config(
}
} else {
stmt = dc_sqlite3_prepare(
context,
sql,
b"DELETE FROM config WHERE keyname=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1015,6 +1102,7 @@ pub unsafe fn dc_sqlite3_set_config(
/* tools, these functions are compatible to the corresponding sqlite3_* functions */
/* the result mus be freed using sqlite3_finalize() */
pub unsafe fn dc_sqlite3_prepare(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
querystr: *const libc::c_char,
) -> *mut sqlite3_stmt {
@@ -1031,6 +1119,7 @@ pub unsafe fn dc_sqlite3_prepare(
) != 0
{
dc_sqlite3_log_error(
context,
sql,
b"Query failed: %s\x00" as *const u8 as *const libc::c_char,
querystr,
@@ -1080,6 +1169,7 @@ pub unsafe fn dc_sqlite3_is_open(sql: &dc_sqlite3_t) -> libc::c_int {
/* the returned string must be free()'d, returns NULL on errors */
pub unsafe fn dc_sqlite3_get_config(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
key: *const libc::c_char,
def: *const libc::c_char,
@@ -1089,6 +1179,7 @@ pub unsafe fn dc_sqlite3_get_config(
return dc_strdup_keep_null(def);
}
stmt = dc_sqlite3_prepare(
context,
sql,
b"SELECT value FROM config WHERE keyname=?;\x00" as *const u8 as *const libc::c_char,
);
@@ -1106,16 +1197,18 @@ pub unsafe fn dc_sqlite3_get_config(
}
pub unsafe fn dc_sqlite3_execute(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
querystr: *const libc::c_char,
) -> libc::c_int {
let mut success = 0;
let mut sqlState = 0;
let stmt = dc_sqlite3_prepare(sql, querystr);
let stmt = dc_sqlite3_prepare(context, sql, querystr);
if !stmt.is_null() {
sqlState = sqlite3_step(stmt);
if sqlState != 101 && sqlState != 100 {
dc_sqlite3_log_error(
context,
sql,
b"Cannot execute \"%s\".\x00" as *const u8 as *const libc::c_char,
querystr,
@@ -1129,6 +1222,7 @@ pub unsafe fn dc_sqlite3_execute(
}
pub unsafe fn dc_sqlite3_set_config_int(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
key: *const libc::c_char,
value: int32_t,
@@ -1140,18 +1234,19 @@ pub unsafe fn dc_sqlite3_set_config_int(
if value_str.is_null() {
return 0;
}
let ret = dc_sqlite3_set_config(sql, key, value_str);
let ret = dc_sqlite3_set_config(context, sql, key, value_str);
free(value_str as *mut libc::c_void);
ret
}
pub unsafe fn dc_sqlite3_get_config_int(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
key: *const libc::c_char,
def: int32_t,
) -> int32_t {
let mut str = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
let mut str = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
if str.is_null() {
return def;
}
@@ -1181,7 +1276,7 @@ pub unsafe fn dc_sqlite3_table_exists(
b"dc_sqlite3_table_exists_(): Out of memory.\x00" as *const u8 as *const libc::c_char,
);
} else {
stmt = dc_sqlite3_prepare(sql, querystr);
stmt = dc_sqlite3_prepare(context, sql, querystr);
if !stmt.is_null() {
sqlState = sqlite3_step(stmt);
if sqlState == 100 {
@@ -1200,6 +1295,7 @@ pub unsafe fn dc_sqlite3_table_exists(
}
pub unsafe fn dc_sqlite3_set_config_int64(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
key: *const libc::c_char,
value: int64_t,
@@ -1211,17 +1307,18 @@ pub unsafe fn dc_sqlite3_set_config_int64(
if value_str.is_null() {
return 0;
}
let ret = dc_sqlite3_set_config(sql, key, value_str);
let ret = dc_sqlite3_set_config(context, sql, key, value_str);
free(value_str as *mut libc::c_void);
ret
}
pub unsafe fn dc_sqlite3_get_config_int64(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
key: *const libc::c_char,
def: int64_t,
) -> int64_t {
let mut str = dc_sqlite3_get_config(sql, key, 0 as *const libc::c_char);
let mut str = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
if str.is_null() {
return def;
}
@@ -1243,7 +1340,7 @@ pub unsafe fn dc_sqlite3_try_execute(
// same as dc_sqlite3_execute() but does not pass error to ui
let mut success = 0;
let mut sql_state = 0;
let stmt = dc_sqlite3_prepare(sql, querystr);
let stmt = dc_sqlite3_prepare(context, sql, querystr);
if !stmt.is_null() {
sql_state = sqlite3_step(stmt);
if sql_state != 101 && sql_state != 100 {
@@ -1263,6 +1360,7 @@ pub unsafe fn dc_sqlite3_try_execute(
}
pub unsafe fn dc_sqlite3_get_rowid(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
table: *const libc::c_char,
field: *const libc::c_char,
@@ -1278,7 +1376,7 @@ pub unsafe fn dc_sqlite3_get_rowid(
field,
value,
);
let mut stmt = dc_sqlite3_prepare(sql, q3);
let mut stmt = dc_sqlite3_prepare(context, sql, q3);
if 100 == sqlite3_step(stmt) {
id = sqlite3_column_int(stmt, 0) as uint32_t
}
@@ -1288,6 +1386,7 @@ pub unsafe fn dc_sqlite3_get_rowid(
}
pub unsafe fn dc_sqlite3_get_rowid2(
context: &dc_context_t,
sql: &mut dc_sqlite3_t,
table: *const libc::c_char,
field: *const libc::c_char,
@@ -1307,7 +1406,7 @@ pub unsafe fn dc_sqlite3_get_rowid2(
field2,
value2,
);
let mut stmt = dc_sqlite3_prepare(sql, q3);
let mut stmt = dc_sqlite3_prepare(context, sql, q3);
if 100 == sqlite3_step(stmt) {
id = sqlite3_column_int(stmt, 0) as uint32_t
}
@@ -1362,7 +1461,8 @@ pub unsafe fn dc_housekeeping(context: &dc_context_t) {
'i' as i32,
);
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT value FROM config;\x00" as *const u8 as *const libc::c_char,
);
while sqlite3_step(stmt) == 100 {
@@ -1378,13 +1478,13 @@ pub unsafe fn dc_housekeeping(context: &dc_context_t) {
files_in_use.count as libc::c_int,
);
/* go through directory and delete unused files */
dir_handle = opendir((*context).blobdir);
dir_handle = opendir(context.blobdir);
if dir_handle.is_null() {
dc_log_warning(
context,
0,
b"Housekeeping: Cannot open %s.\x00" as *const u8 as *const libc::c_char,
(*context).blobdir,
context.blobdir,
);
} else {
/* avoid deletion of files that are just created to build a message object */
@@ -1429,7 +1529,7 @@ pub unsafe fn dc_housekeeping(context: &dc_context_t) {
free(path as *mut libc::c_void);
path = dc_mprintf(
b"%s/%s\x00" as *const u8 as *const libc::c_char,
(*context).blobdir,
context.blobdir,
name,
);
@@ -1526,7 +1626,7 @@ unsafe fn maybe_add_from_param(
param_id: libc::c_int,
) {
let mut param = dc_param_new();
let mut stmt = dc_sqlite3_prepare((*context).sql, query);
let mut stmt = dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(), query);
while sqlite3_step(stmt) == 100 {
dc_param_set_packed(param, sqlite3_column_text(stmt, 0) as *const libc::c_char);
let mut file = dc_param_get(param, param_id, 0 as *const libc::c_char);

16
src/dc_stock.rs
View File

@@ -19,14 +19,14 @@ unsafe fn get_string(
mut qty: libc::c_int,
) -> *mut libc::c_char {
let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
if !context.is_null() {
ret = ((*context).cb)(
context,
Event::GET_STRING,
id as uintptr_t,
qty as uintptr_t,
) as *mut libc::c_char;
}
ret = ((*context).cb)(
context,
Event::GET_STRING,
id as uintptr_t,
qty as uintptr_t,
) as *mut libc::c_char;
if ret.is_null() {
ret = default_string(id)
}

37
src/dc_token.rs
View File

@@ -18,11 +18,11 @@ pub unsafe fn dc_token_save(
mut token: *const libc::c_char,
) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || token.is_null())
{
if !token.is_null() {
// foreign_id may be 0
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO tokens (namespc, foreign_id, token, timestamp) VALUES (?, ?, ?, ?);\x00"
as *const u8 as *const libc::c_char,
);
@@ -41,20 +41,21 @@ pub unsafe fn dc_token_lookup(
) -> *mut libc::c_char {
let mut token: *mut libc::c_char = 0 as *mut libc::c_char;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, namespc as libc::c_int);
sqlite3_bind_int(stmt, 2i32, foreign_id as libc::c_int);
sqlite3_step(stmt);
token = dc_strdup_keep_null(sqlite3_column_text(stmt, 0i32) as *mut libc::c_char)
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, namespc as libc::c_int);
sqlite3_bind_int(stmt, 2i32, foreign_id as libc::c_int);
sqlite3_step(stmt);
token = dc_strdup_keep_null(sqlite3_column_text(stmt, 0i32) as *mut libc::c_char);
sqlite3_finalize(stmt);
return token;
token
}
pub unsafe fn dc_token_exists(
mut context: &dc_context_t,
mut namespc: dc_tokennamespc_t,
@@ -62,10 +63,10 @@ pub unsafe fn dc_token_exists(
) -> libc::c_int {
let mut exists: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint || token.is_null())
{
if !token.is_null() {
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM tokens WHERE namespc=? AND token=?;\x00" as *const u8
as *const libc::c_char,
);

58
src/dc_tools.rs
View File

@@ -890,27 +890,28 @@ pub unsafe fn dc_gm2local_offset() -> libc::c_long {
pub unsafe fn dc_smeared_time(mut context: &dc_context_t) -> time_t {
/* function returns a corrected time(NULL) */
let mut now: time_t = time(0 as *mut time_t);
pthread_mutex_lock(&mut (*context).smear_critical);
if (*context).last_smeared_timestamp >= now {
now = (*context).last_smeared_timestamp + 1i32 as libc::c_long
let mut ts = *context.last_smeared_timestamp.clone().read().unwrap();
if ts >= now {
now = ts + 1;
}
pthread_mutex_unlock(&mut (*context).smear_critical);
return now;
now
}
pub unsafe fn dc_create_smeared_timestamp(mut context: &dc_context_t) -> time_t {
let mut now: time_t = time(0 as *mut time_t);
let mut ret: time_t = now;
pthread_mutex_lock(&mut (*context).smear_critical);
if ret <= (*context).last_smeared_timestamp {
ret = (*context).last_smeared_timestamp + 1i32 as libc::c_long;
if ret - now > 5i32 as libc::c_long {
ret = now + 5i32 as libc::c_long
let mut ts = *context.last_smeared_timestamp.clone().write().unwrap();
if ret <= ts {
ret = ts + 1;
if ret - now > 5 {
ret = now + 5
}
}
(*context).last_smeared_timestamp = ret;
pthread_mutex_unlock(&mut (*context).smear_critical);
return ret;
ts = ret;
ret
}
pub unsafe fn dc_create_smeared_timestamps(
mut context: &dc_context_t,
mut count: libc::c_int,
@@ -919,16 +920,13 @@ pub unsafe fn dc_create_smeared_timestamps(
let mut now: time_t = time(0 as *mut time_t);
let mut start: time_t =
now + (if count < 5i32 { count } else { 5i32 }) as libc::c_long - count as libc::c_long;
pthread_mutex_lock(&mut (*context).smear_critical);
start = if (*context).last_smeared_timestamp + 1i32 as libc::c_long > start {
(*context).last_smeared_timestamp + 1i32 as libc::c_long
} else {
start
};
(*context).last_smeared_timestamp = start + (count - 1i32) as libc::c_long;
pthread_mutex_unlock(&mut (*context).smear_critical);
return start;
let mut ts = *context.last_smeared_timestamp.clone().write().unwrap();
start = if ts + 1 > start { ts + 1 } else { start };
ts = start + ((count - 1) as time_t);
start
}
/* Message-ID tools */
pub unsafe fn dc_create_id() -> *mut libc::c_char {
/* generate an id. the generated ID should be as short and as unique as possible:
@@ -1268,7 +1266,7 @@ pub unsafe fn dc_get_abs_path(
let mut current_block: u64;
let mut success: libc::c_int = 0i32;
let mut pathNfilename_abs: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null() || pathNfilename.is_null()) {
if !pathNfilename.is_null() {
pathNfilename_abs = dc_strdup(pathNfilename);
if strncmp(
pathNfilename_abs,
@@ -1276,13 +1274,13 @@ pub unsafe fn dc_get_abs_path(
8,
) == 0i32
{
if (*context).blobdir.is_null() {
if context.blobdir.is_null() {
current_block = 3805228753452640762;
} else {
dc_str_replace(
&mut pathNfilename_abs,
b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
(*context).blobdir,
context.blobdir,
);
current_block = 6937071982253665452;
}
@@ -1638,7 +1636,7 @@ pub unsafe fn dc_is_blobdir_path(
mut context: &dc_context_t,
mut path: *const libc::c_char,
) -> libc::c_int {
if strncmp(path, (*context).blobdir, strlen((*context).blobdir)) == 0i32
if strncmp(path, context.blobdir, strlen(context.blobdir)) == 0i32
|| strncmp(path, b"$BLOBDIR\x00" as *const u8 as *const libc::c_char, 8) == 0i32
{
return 1i32;
@@ -1646,13 +1644,13 @@ pub unsafe fn dc_is_blobdir_path(
return 0i32;
}
pub unsafe fn dc_make_rel_path(mut context: &dc_context_t, mut path: *mut *mut libc::c_char) {
if context.is_null() || path.is_null() || (*path).is_null() {
if path.is_null() || (*path).is_null() {
return;
}
if strncmp(*path, (*context).blobdir, strlen((*context).blobdir)) == 0i32 {
if strncmp(*path, context.blobdir, strlen(context.blobdir)) == 0i32 {
dc_str_replace(
path,
(*context).blobdir,
context.blobdir,
b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
);
};
@@ -1664,7 +1662,7 @@ pub unsafe fn dc_make_rel_and_copy(
let mut success: libc::c_int = 0i32;
let mut filename: *mut libc::c_char = 0 as *mut libc::c_char;
let mut blobdir_path: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null() || path.is_null() || (*path).is_null()) {
if !(path.is_null() || (*path).is_null()) {
if 0 != dc_is_blobdir_path(context, *path) {
dc_make_rel_path(context, path);
success = 1i32