Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-05-08 17:36:29 +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

1096
examples/repl/main.rs
View File

File diff suppressed because it is too large Load Diff

55
examples/simple.rs
View File

@@ -1,7 +1,7 @@
extern crate deltachat; extern crate deltachat;
use std::ffi::{CStr, CString}; use std::ffi::{CStr, CString};
use std::ptr::NonNull; use std::sync::{Arc, RwLock};
use tempfile::tempdir; use tempfile::tempdir;
use deltachat::constants::Event; use deltachat::constants::Event;
@@ -49,61 +49,70 @@ extern "C" fn cb(_ctx: &dc_context_t, event: Event, data1: usize, data2: usize)
} }
} }
struct Wrapper(NonNull<dc_context_t>);
unsafe impl std::marker::Send for Wrapper {}
unsafe impl std::marker::Sync for Wrapper {}
fn main() { fn main() {
unsafe { unsafe {
let ctx = dc_context_new(cb, std::ptr::null_mut(), std::ptr::null_mut()); let ctx = dc_context_new(cb, std::ptr::null_mut(), std::ptr::null_mut());
let info = dc_get_info(ctx); let info = dc_get_info(&ctx);
let info_s = CStr::from_ptr(info); let info_s = CStr::from_ptr(info);
println!("info: {}", info_s.to_str().unwrap()); println!("info: {}", info_s.to_str().unwrap());
let sendable_ctx = Wrapper(NonNull::new(ctx).unwrap()); let ctx = Arc::new(RwLock::new(ctx));
let ctx1 = ctx.clone();
let t1 = std::thread::spawn(move || loop { let t1 = std::thread::spawn(move || loop {
dc_perform_imap_jobs(sendable_ctx.0.as_ptr()); dc_perform_imap_jobs(&ctx1.clone().read().unwrap());
dc_perform_imap_fetch(sendable_ctx.0.as_ptr()); dc_perform_imap_fetch(&ctx1.clone().read().unwrap());
dc_perform_imap_idle(sendable_ctx.0.as_ptr()); dc_perform_imap_idle(&ctx1.clone().read().unwrap());
}); });
let sendable_ctx = Wrapper(NonNull::new(ctx).unwrap()); let ctx1 = ctx.clone();
let t2 = std::thread::spawn(move || loop { let t2 = std::thread::spawn(move || loop {
dc_perform_smtp_jobs(sendable_ctx.0.as_ptr()); dc_perform_smtp_jobs(&ctx1.clone().read().unwrap());
dc_perform_smtp_idle(sendable_ctx.0.as_ptr()); dc_perform_smtp_idle(&ctx1.clone().read().unwrap());
}); });
let dir = tempdir().unwrap(); let dir = tempdir().unwrap();
let dbfile = CString::new(dir.path().join("db.sqlite").to_str().unwrap()).unwrap(); let dbfile = CString::new(dir.path().join("db.sqlite").to_str().unwrap()).unwrap();
println!("opening database {:?}", dbfile); println!("opening database {:?}", dbfile);
dc_open(ctx, dbfile.as_ptr(), std::ptr::null());
dc_open(
&mut ctx.clone().write().unwrap(),
dbfile.as_ptr(),
std::ptr::null(),
);
println!("configuring"); println!("configuring");
dc_set_config( dc_set_config(
ctx, &ctx.clone().read().unwrap(),
CString::new("addr").unwrap().as_ptr(), CString::new("addr").unwrap().as_ptr(),
CString::new("d@testrun.org").unwrap().as_ptr(), CString::new("d@testrun.org").unwrap().as_ptr(),
); );
dc_set_config( dc_set_config(
ctx, &ctx.clone().read().unwrap(),
CString::new("mail_pw").unwrap().as_ptr(), CString::new("mail_pw").unwrap().as_ptr(),
CString::new("***").unwrap().as_ptr(), CString::new("***").unwrap().as_ptr(),
); );
dc_configure(ctx); dc_configure(&ctx.clone().read().unwrap());
std::thread::sleep_ms(4000); std::thread::sleep_ms(4000);
let email = CString::new("dignifiedquire@gmail.com").unwrap(); let email = CString::new("dignifiedquire@gmail.com").unwrap();
println!("sending a message"); println!("sending a message");
let contact_id = dc_create_contact(ctx, std::ptr::null(), email.as_ptr()); let contact_id = dc_create_contact(
let chat_id = dc_create_chat_by_contact_id(ctx, contact_id); &ctx.clone().read().unwrap(),
std::ptr::null(),
email.as_ptr(),
);
let chat_id = dc_create_chat_by_contact_id(&ctx.clone().read().unwrap(), contact_id);
let msg_text = CString::new("Hi, here is my first message!").unwrap(); let msg_text = CString::new("Hi, here is my first message!").unwrap();
dc_send_text_msg(ctx, chat_id, msg_text.as_ptr()); dc_send_text_msg(&ctx.clone().read().unwrap(), chat_id, msg_text.as_ptr());
println!("fetching chats.."); println!("fetching chats..");
let chats = dc_get_chatlist(ctx, 0, std::ptr::null(), 0); let ctx1 = ctx.clone();
let ctx = ctx1.read().unwrap();
let chats = dc_get_chatlist(&ctx, 0, std::ptr::null(), 0);
for i in 0..dc_chatlist_get_cnt(chats) { for i in 0..dc_chatlist_get_cnt(chats) {
let summary = dc_chatlist_get_summary(chats, 0, std::ptr::null_mut()); let summary = dc_chatlist_get_summary(chats, 0, std::ptr::null_mut());
@@ -125,7 +134,7 @@ fn main() {
} }
dc_chatlist_unref(chats); dc_chatlist_unref(chats);
// let msglist = dc_get_chat_msgs(ctx, chat_id, 0, 0); // let msglist = dc_get_chat_msgs(&ctx.clone().read().unwrap(), chat_id, 0, 0);
// for i in 0..dc_array_get_cnt(msglist) { // for i in 0..dc_array_get_cnt(msglist) {
// let msg_id = dc_array_get_id(msglist, i); // let msg_id = dc_array_get_id(msglist, i);
// let msg = dc_get_msg(context, msg_id); // let msg = dc_get_msg(context, msg_id);

21
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.is_null() {
if !(*peerstate).public_key.is_null() { if !(*peerstate).public_key.is_null() {
old_public_fingerprint = (*peerstate).public_key_fingerprint; 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() if old_public_fingerprint.is_null()
|| *old_public_fingerprint.offset(0isize) as libc::c_int == 0i32 || *old_public_fingerprint.offset(0isize) as libc::c_int == 0i32
|| (*peerstate).public_key_fingerprint.is_null() || (*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() { if !(*peerstate).gossip_key.is_null() {
old_gossip_fingerprint = (*peerstate).gossip_key_fingerprint; 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() if old_gossip_fingerprint.is_null()
|| *old_gossip_fingerprint.offset(0isize) as libc::c_int == 0i32 || *old_gossip_fingerprint.offset(0isize) as libc::c_int == 0i32
|| (*peerstate).gossip_key_fingerprint.is_null() || (*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()) { if !(peerstate.is_null() || addr.is_null()) {
dc_apeerstate_empty(peerstate); dc_apeerstate_empty(peerstate);
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, addr, -1i32, None); sqlite3_bind_text(stmt, 1i32, addr, -1i32, None);
@@ -370,7 +374,9 @@ pub unsafe fn dc_apeerstate_load_by_fingerprint(
if !(peerstate.is_null() || fingerprint.is_null()) { if !(peerstate.is_null() || fingerprint.is_null()) {
dc_apeerstate_empty(peerstate); dc_apeerstate_empty(peerstate);
stmt = 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 public_key_fingerprint=? COLLATE NOCASE OR gossip_key_fingerprint=? COLLATE NOCASE ORDER BY public_key_fingerprint=? DESC;\x00" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, fingerprint, -1i32, None); sqlite3_bind_text(stmt, 1i32, fingerprint, -1i32, None);
@@ -397,6 +403,7 @@ pub unsafe fn dc_apeerstate_save_to_db(
} }
if 0 != create { if 0 != create {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
(*peerstate).context,
sql, sql,
b"INSERT INTO acpeerstates (addr) VALUES(?);\x00" as *const u8 as *const libc::c_char, 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 { if 0 != (*peerstate).to_save & 0x2i32 || 0 != create {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int64(stmt, 1i32, (*peerstate).last_seen as sqlite3_int64); 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 { } else if 0 != (*peerstate).to_save & 0x1i32 {
stmt = 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" b"UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? WHERE addr=?;\x00"
as *const u8 as *const libc::c_char); as *const u8 as *const libc::c_char);
sqlite3_bind_int64(stmt, 1i32, (*peerstate).last_seen as sqlite3_int64); 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE chats SET blocked=? WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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); dc_chat_empty(chat);
stmt = stmt =
dc_sqlite3_prepare( dc_sqlite3_prepare(
(*chat).context,
&mut (*chat).context.sql.lock().unwrap(), &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" 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 as *const u8 as *const libc::c_char
@@ -325,10 +327,11 @@ pub unsafe fn dc_create_or_lookup_nchat_by_contact_id(
); );
} else { } 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 !stmt.is_null() {
if !(sqlite3_step(stmt) != 101i32) { if !(sqlite3_step(stmt) != 101i32) {
chat_id = dc_sqlite3_get_rowid( chat_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"chats\x00" as *const u8 as *const libc::c_char, b"chats\x00" as *const u8 as *const libc::c_char,
b"grpid\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, chat_id,
contact_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) { if !(sqlite3_step(stmt) != 101i32) {
sqlite3_free(q as *mut libc::c_void); sqlite3_free(q as *mut libc::c_void);
q = 0 as *mut libc::c_char; q = 0 as *mut libc::c_char;
@@ -383,6 +386,7 @@ pub unsafe fn dc_lookup_real_nchat_by_contact_id(
} }
stmt = stmt =
dc_sqlite3_prepare( dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &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" 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); as *const u8 as *const libc::c_char);
@@ -565,6 +569,7 @@ unsafe fn prepare_msg_raw(
); );
} else { } else {
let mut from: *mut libc::c_char = dc_sqlite3_get_config( let mut from: *mut libc::c_char = dc_sqlite3_get_config(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 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); free(from as *mut libc::c_void);
if (*chat).type_0 == 100i32 { if (*chat).type_0 == 100i32 {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT contact_id FROM chats_contacts WHERE chat_id=?;\x00" as *const u8 b"SELECT contact_id FROM chats_contacts WHERE chat_id=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -625,6 +631,7 @@ unsafe fn prepare_msg_raw(
we do not send the message out at all */ we do not send the message out at all */
do_guarantee_e2ee = 0i32; do_guarantee_e2ee = 0i32;
e2ee_enabled = dc_sqlite3_get_config_int( e2ee_enabled = dc_sqlite3_get_config_int(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char, b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32, 1i32,
@@ -634,7 +641,7 @@ unsafe fn prepare_msg_raw(
let mut can_encrypt: libc::c_int = 1i32; let mut can_encrypt: libc::c_int = 1i32;
let mut all_mutual: libc::c_int = 1i32; let mut all_mutual: libc::c_int = 1i32;
stmt = 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" 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 as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -677,6 +684,7 @@ unsafe fn prepare_msg_raw(
do_guarantee_e2ee = 1i32 do_guarantee_e2ee = 1i32
} else if 0 } else if 0
!= last_msg_in_chat_encrypted( != last_msg_in_chat_encrypted(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
(*chat).id, (*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) { if 0 != dc_param_exists((*msg).param, DC_PARAM_SET_LATITUDE as libc::c_int) {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"INSERT INTO locations \ b"INSERT INTO locations \
(timestamp,from_id,chat_id, latitude,longitude,independent)\ (timestamp,from_id,chat_id, latitude,longitude,independent)\
@@ -776,6 +785,7 @@ unsafe fn prepare_msg_raw(
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
location_id = dc_sqlite3_get_rowid2( location_id = dc_sqlite3_get_rowid2(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"locations\x00" as *const u8 as *const libc::c_char, b"locations\x00" as *const u8 as *const libc::c_char,
b"timestamp\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 // add message to the database
stmt = 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" 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 as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -825,6 +836,7 @@ unsafe fn prepare_msg_raw(
); );
} else { } else {
msg_id = dc_sqlite3_get_rowid( msg_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"msgs\x00" as *const u8 as *const libc::c_char, b"msgs\x00" as *const u8 as *const libc::c_char,
b"rfc724_mid\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()) || parent_references.is_null())
{ {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, (*chat).id as libc::c_int); 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; stmt = 0 as *mut sqlite3_stmt;
if 0 == success { if 0 == success {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, (*chat).id as libc::c_int); 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 * Sending messages
******************************************************************************/ ******************************************************************************/
unsafe fn last_msg_in_chat_encrypted( unsafe fn last_msg_in_chat_encrypted(
mut sql: &mut dc_sqlite3_t, context: &dc_context_t,
mut chat_id: uint32_t, sql: &mut dc_sqlite3_t,
chat_id: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut last_is_encrypted: libc::c_int = 0i32; let mut last_is_encrypted: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int); 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 { 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 success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
(*chat).context,
&mut (*chat).context.sql.lock().unwrap(), &mut (*chat).context.sql.lock().unwrap(),
b"UPDATE chats SET param=? WHERE id=?\x00" as *const u8 as *const libc::c_char, 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT contact_id FROM chats_contacts WHERE chat_id=? AND contact_id=?;\x00" as *const u8 b"SELECT contact_id FROM chats_contacts WHERE chat_id=? AND contact_id=?;\x00" as *const u8
as *const libc::c_char, 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) { 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( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE chats SET archived=0 WHERE id=?\x00" as *const u8 as *const libc::c_char, 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 => {} 14513523936503887211 => {}
_ => { _ => {
stmt = 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" b"INSERT INTO msgs (chat_id, from_id, timestamp, type, state, txt, param, hidden) VALUES (?,?,?, ?,?,?,?,?);\x00"
as *const u8 as as *const u8 as
*const libc::c_char); *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 { 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 draft_msg_id: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT id FROM msgs WHERE chat_id=? AND state=?;\x00" as *const u8 as *const libc::c_char, 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 !ret.is_null() {
if chat_id == 1i32 as libc::c_uint { if chat_id == 1i32 as libc::c_uint {
let mut show_emails: libc::c_int = dc_sqlite3_get_config_int( let mut show_emails: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"show_emails\x00" as *const u8 as *const libc::c_char, b"show_emails\x00" as *const u8 as *const libc::c_char,
0i32, 0i32,
); );
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, if show_emails == 2i32 { 0i32 } else { 1i32 }); sqlite3_bind_int(stmt, 1i32, if show_emails == 2i32 { 0i32 } else { 1i32 });
} else if chat_id == 5i32 as libc::c_uint { } else if chat_id == 5i32 as libc::c_uint {
stmt = 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" 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) as *const u8 as *const libc::c_char)
} else { } else {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int); 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 ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM msgs WHERE chat_id=?;\x00" as *const u8 as *const libc::c_char, 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 ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM msgs WHERE state=10 AND hidden=0 AND chat_id=?;\x00" b"SELECT COUNT(*) FROM msgs WHERE state=10 AND hidden=0 AND chat_id=?;\x00"
as *const u8 as *const libc::c_char, 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; let mut update: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
check = dc_sqlite3_prepare( check = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT id FROM msgs WHERE chat_id=? AND state=10;\x00" as *const u8 b"SELECT id FROM msgs WHERE chat_id=? AND state=10;\x00" as *const u8
as *const libc::c_char, 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); sqlite3_bind_int(check, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(check) != 100i32) { if !(sqlite3_step(check) != 100i32) {
update = dc_sqlite3_prepare( update = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE chat_id=? AND state=10;\x00" as *const u8 b"UPDATE msgs SET state=13 WHERE chat_id=? AND state=10;\x00" as *const u8
as *const libc::c_char, 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; let mut update: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
check = dc_sqlite3_prepare( check = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT id FROM msgs WHERE state=10;\x00" as *const u8 as *const libc::c_char, b"SELECT id FROM msgs WHERE state=10;\x00" as *const u8 as *const libc::c_char,
); );
if !(sqlite3_step(check) != 100i32) { if !(sqlite3_step(check) != 100i32) {
update = dc_sqlite3_prepare( update = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE state=10;\x00" as *const u8 as *const libc::c_char, 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 { ) -> *mut dc_array_t {
let mut ret: *mut dc_array_t = dc_array_new(100i32 as size_t); let mut ret: *mut dc_array_t = dc_array_new(100i32 as size_t);
let mut stmt: *mut sqlite3_stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int); sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -1432,6 +1464,7 @@ pub unsafe fn dc_archive_chat(
} }
if 0 != archive { if 0 != archive {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE chat_id=? AND state=10;\x00" as *const u8 b"UPDATE msgs SET state=13 WHERE chat_id=? AND state=10;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -1441,6 +1474,7 @@ pub unsafe fn dc_archive_chat(
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
} }
let mut stmt_0: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt_0: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE chats SET archived=? WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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) { 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. */ /* 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 obj: *mut dc_chat_t = dc_chat_new(context);
let mut q3: *mut libc::c_char = 0 as *mut libc::c_char; let mut q3: *mut libc::c_char = 0 as *mut libc::c_char;
if !(chat_id <= 9i32 as libc::c_uint) { if !(chat_id <= 9i32 as libc::c_uint) {
if !(0 == dc_chat_load_from_db(obj, chat_id)) { if !(0 == dc_chat_load_from_db(obj, chat_id)) {
pending_transaction = 1i32;
q3 = sqlite3_mprintf( q3 = sqlite3_mprintf(
b"DELETE FROM msgs_mdns WHERE msg_id IN (SELECT id FROM msgs WHERE chat_id=%i);\x00" 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, as *const u8 as *const libc::c_char,
chat_id, 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); sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char; q3 = 0 as *mut libc::c_char;
q3 = sqlite3_mprintf( q3 = sqlite3_mprintf(
b"DELETE FROM msgs WHERE chat_id=%i;\x00" as *const u8 as *const libc::c_char, b"DELETE FROM msgs WHERE chat_id=%i;\x00" as *const u8 as *const libc::c_char,
chat_id, 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); sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char; q3 = 0 as *mut libc::c_char;
q3 = sqlite3_mprintf( 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, as *const libc::c_char,
chat_id, 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); sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char; q3 = 0 as *mut libc::c_char;
q3 = sqlite3_mprintf( 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, as *const libc::c_char,
chat_id, 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); sqlite3_free(q3 as *mut libc::c_void);
q3 = 0 as *mut libc::c_char; q3 = 0 as *mut libc::c_char;
pending_transaction = 0i32;
(context.cb)( (context.cb)(
context, context,
Event::MSGS_CHANGED, Event::MSGS_CHANGED,
@@ -1524,7 +1556,8 @@ pub unsafe fn dc_get_chat_contacts(
if !(chat_id == 1i32 as libc::c_uint) { 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 */ /* 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 = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int); 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); draft_txt = dc_stock_str_repl_string(context, 14i32, chat_name);
grpid = dc_create_id(); grpid = dc_create_id();
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"INSERT INTO chats (type, name, grpid, param) VALUES(?, ?, ?, \'U=1\');\x00" as *const u8 b"INSERT INTO chats (type, name, grpid, param) VALUES(?, ?, ?, \'U=1\');\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -1577,6 +1611,7 @@ pub unsafe fn dc_create_group_chat(
sqlite3_bind_text(stmt, 3i32, grpid, -1i32, None); sqlite3_bind_text(stmt, 3i32, grpid, -1i32, None);
if !(sqlite3_step(stmt) != 101i32) { if !(sqlite3_step(stmt) != 101i32) {
chat_id = dc_sqlite3_get_rowid( chat_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"chats\x00" as *const u8 as *const libc::c_char, b"chats\x00" as *const u8 as *const libc::c_char,
b"grpid\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! */ /* 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 ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"INSERT INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)\x00" as *const u8 b"INSERT INTO chats_contacts (chat_id, contact_id) VALUES(?, ?)\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -1671,6 +1707,7 @@ pub unsafe fn dc_add_contact_to_chat_ex(
dc_chat_update_param(chat); dc_chat_update_param(chat);
} }
self_addr = dc_sqlite3_get_config( self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\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; return 0i32;
} }
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT id FROM chats WHERE id=? AND (type=120 OR type=130);\x00" as *const u8 b"SELECT id FROM chats WHERE id=? AND (type=120 OR type=130);\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -1791,6 +1829,7 @@ pub unsafe fn dc_set_gossiped_timestamp(
timestamp as libc::c_int, timestamp as libc::c_int,
); );
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE chats SET gossiped_timestamp=? WHERE id=?;\x00" as *const u8 b"UPDATE chats SET gossiped_timestamp=? WHERE id=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -1805,6 +1844,7 @@ pub unsafe fn dc_set_gossiped_timestamp(
timestamp as libc::c_int, timestamp as libc::c_int,
); );
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"UPDATE chats SET gossiped_timestamp=?;\x00" as *const u8 as *const libc::c_char, 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, chat_id,
contact_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.cb)(
context, context,
Event::CHAT_MODIFIED, Event::CHAT_MODIFIED,
@@ -1903,6 +1943,7 @@ pub unsafe fn dc_set_group_explicitly_left(
) { ) {
if 0 == dc_is_group_explicitly_left(context, grpid) { if 0 == dc_is_group_explicitly_left(context, grpid) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"INSERT INTO leftgrps (grpid) VALUES(?);\x00" as *const u8 as *const libc::c_char, 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, mut grpid: *const libc::c_char,
) -> libc::c_int { ) -> libc::c_int {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT id FROM leftgrps WHERE grpid=?;\x00" as *const u8 as *const libc::c_char, 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, new_name,
chat_id, 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 { if dc_param_get_int((*chat).param, 'U' as i32, 0i32) == 0i32 {
(*msg).type_0 = 10i32; (*msg).type_0 = 10i32;
(*msg).text = dc_stock_system_msg( (*msg).text = dc_stock_system_msg(
@@ -2081,11 +2123,9 @@ pub unsafe fn dc_forward_msgs(
mut msg_cnt: libc::c_int, mut msg_cnt: libc::c_int,
mut chat_id: uint32_t, mut chat_id: uint32_t,
) { ) {
let mut current_block: u64;
let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context); 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 chat: *mut dc_chat_t = dc_chat_new(context);
let mut contact: *mut dc_contact_t = dc_contact_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 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 idsstr: *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 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 curr_timestamp: time_t = 0i32 as time_t;
let mut original_param: *mut dc_param_t = dc_param_new(); 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) { if !(msg_ids.is_null() || msg_cnt <= 0i32 || chat_id <= 9i32 as libc::c_uint) {
transaction_pending = 1i32;
dc_unarchive_chat(context, chat_id); dc_unarchive_chat(context, chat_id);
context.smtp.lock().unwrap().log_connect_errors = 1i32; context.smtp.lock().unwrap().log_connect_errors = 1i32;
if !(0 == dc_chat_load_from_db(chat, chat_id)) { 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, as *const libc::c_char,
idsstr, idsstr,
); );
stmt = dc_sqlite3_prepare(&mut context.sql.lock().unwrap(), q3); stmt = dc_sqlite3_prepare(context, &mut context.sql.lock().unwrap(), q3);
loop { loop {
if !(sqlite3_step(stmt) == 100i32) { if !(sqlite3_step(stmt) == 100i32) {
current_block = 10758786907990354186;
break; break;
} }
let mut src_msg_id: libc::c_int = sqlite3_column_int(stmt, 0i32); 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) { if 0 == dc_msg_load_from_db(msg, context, src_msg_id as uint32_t) {
current_block = 2015322633586469911;
break; break;
} }
dc_param_set_packed(original_param, (*(*msg).param).packed); 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, 0 as *mut libc::c_uint,
); );
} }
match current_block {
2015322633586469911 => {}
_ => transaction_pending = 0i32,
}
} }
} }
if !created_db_entries.is_null() { 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 { } else if (*chat).type_0 == 100i32 {
let mut r: libc::c_int = 0; let mut r: libc::c_int = 0;
let mut stmt: *mut sqlite3_stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, (*chat).id as libc::c_int); 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 { ) -> libc::c_int {
let mut ret: libc::c_int = 0i32; let mut ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;\x00" as *const u8 b"SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;\x00" as *const u8
as *const libc::c_char, 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() { if !(*context.sql.lock().unwrap()).cobj.is_null() {
/* no database, no chats - this is no error (needed eg. for information) */ /* no database, no chats - this is no error (needed eg. for information) */
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM chats WHERE id>9 AND blocked=0;\x00" as *const u8 b"SELECT COUNT(*) FROM chats WHERE id>9 AND blocked=0;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -2365,6 +2401,7 @@ pub unsafe fn dc_get_chat_id_by_grpid(
} }
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT id, blocked, type FROM chats WHERE grpid=?;\x00" as *const u8 b"SELECT id, blocked, type FROM chats WHERE grpid=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -2396,7 +2433,8 @@ pub unsafe fn dc_add_device_msg(
); );
if !text.is_null() { if !text.is_null() {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int); 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); sqlite3_bind_text(stmt, 8i32, rfc724_mid, -1i32, None);
if !(sqlite3_step(stmt) != 101i32) { if !(sqlite3_step(stmt) != 101i32) {
msg_id = dc_sqlite3_get_rowid( msg_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"msgs\x00" as *const u8 as *const libc::c_char, b"msgs\x00" as *const u8 as *const libc::c_char,
b"rfc724_mid\x00" as *const u8 as *const libc::c_char, b"rfc724_mid\x00" as *const u8 as *const libc::c_char,

24
src/dc_chatlist.rs
View File

@@ -143,14 +143,19 @@ unsafe fn dc_chatlist_load_from_db(
// shown at all permanent in the chatlist. // shown at all permanent in the chatlist.
if 0 != query_contact_id { if 0 != query_contact_id {
stmt = 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.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" 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); as *const u8 as *const libc::c_char
);
sqlite3_bind_int(stmt, 1i32, query_contact_id as libc::c_int); sqlite3_bind_int(stmt, 1i32, query_contact_id as libc::c_int);
current_block = 3437258052017859086; current_block = 3437258052017859086;
} else if 0 != listflags & 0x1i32 { } else if 0 != listflags & 0x1i32 {
stmt = 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=1 GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00" 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); as *const u8 as *const libc::c_char);
current_block = 3437258052017859086; current_block = 3437258052017859086;
@@ -165,7 +170,9 @@ unsafe fn dc_chatlist_load_from_db(
add_archived_link_item = 1i32 add_archived_link_item = 1i32
} }
stmt = 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" 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); as *const u8 as *const libc::c_char);
current_block = 3437258052017859086; current_block = 3437258052017859086;
@@ -178,7 +185,9 @@ unsafe fn dc_chatlist_load_from_db(
} else { } else {
strLikeCmd = dc_mprintf(b"%%%s%%\x00" as *const u8 as *const libc::c_char, query); strLikeCmd = dc_mprintf(b"%%%s%%\x00" as *const u8 as *const libc::c_char, query);
stmt = 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.name LIKE ? GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;\x00" 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 as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -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 { pub unsafe fn dc_get_archived_cnt(mut context: &dc_context_t) -> libc::c_int {
let mut ret: libc::c_int = 0i32; let mut ret: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;\x00" as *const u8 b"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -237,7 +247,9 @@ 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 ret: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = stmt =
dc_sqlite3_prepare(&mut context.sql.lock().unwrap(), 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" 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); 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 */ /* we have an index over the state-column, this should be sufficient as there are typically only few fresh messages */

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); 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 { 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 1i32
} else { } else {
0i32 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 { pub unsafe fn dc_is_configured(mut context: &dc_context_t) -> libc::c_int {
return if 0 return if 0
!= dc_sqlite3_get_config_int( != dc_sqlite3_get_config_int(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"configured\x00" as *const u8 as *const libc::c_char, b"configured\x00" as *const u8 as *const libc::c_char,
0i32, 0i32,
@@ -90,14 +93,14 @@ pub unsafe fn dc_is_configured(mut context: &dc_context_t) -> libc::c_int {
0i32 0i32
}; };
} }
pub unsafe fn dc_stop_ongoing_process(mut context: &dc_context_t) { pub unsafe fn dc_stop_ongoing_process(context: &dc_context_t) {
if 0 != (*context).ongoing_running && (*context).shall_stop_ongoing == 0i32 { if 0 != context.ongoing_running && *context.shall_stop_ongoing.clone().read().unwrap() == 0 {
dc_log_info( dc_log_info(
context, context,
0i32, 0i32,
b"Signaling the ongoing process to stop ASAP.\x00" as *const u8 as *const libc::c_char, 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 { } else {
dc_log_info( dc_log_info(
context, 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.inbox.clone().lock().unwrap());
dc_imap_disconnect( dc_imap_disconnect(
context, context,
&mut context.sentbox_thread.imap.clone().lock().unwrap(), &mut context
.sentbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
); );
dc_imap_disconnect( dc_imap_disconnect(
context, 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()); dc_smtp_disconnect(&mut context.smtp.clone().lock().unwrap());
context.smtp.clone().lock().unwrap().log_connect_errors = 1i32; context.smtp.clone().lock().unwrap().log_connect_errors = 1i32;
context.inbox.clone().lock().unwrap().log_connect_errors = 1i32; context.inbox.clone().lock().unwrap().log_connect_errors = 1i32;
context context
.sentbox_thread .sentbox_thread
.clone()
.lock()
.unwrap()
.imap .imap
.clone() .clone()
.lock() .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; .log_connect_errors = 1i32;
context context
.mvbox_thread .mvbox_thread
.clone()
.lock()
.unwrap()
.imap .imap
.clone() .clone()
.lock() .lock()
@@ -161,7 +186,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
0i32, 0i32,
b"Configure ...\x00" as *const u8 as *const libc::c_char, 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.cb)(
context, context,
Event::CONFIGURE_PROGRESS, 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(); param = dc_loginparam_new();
dc_loginparam_read( dc_loginparam_read(
context,
param, param,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"\x00" as *const u8 as *const libc::c_char, 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. // the used oauth2 addr may differ, check this.
// if dc_get_oauth2_addr() is not available in the oauth2 implementation, // if dc_get_oauth2_addr() is not available in the oauth2 implementation,
// just use the given one. // just use the given one.
if 0 != context.shall_stop_ongoing { if 0 != *context.shall_stop_ongoing.clone().read().unwrap() {
current_block = 2927484062889439186; current_block = 2927484062889439186;
} else { } else {
(context.cb)( (context.cb)(
@@ -219,7 +245,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
(*param).addr, (*param).addr,
); );
} }
if 0 != context.shall_stop_ongoing { if 0 != *context.shall_stop_ongoing.clone().read().unwrap() {
current_block = 2927484062889439186; current_block = 2927484062889439186;
} else { } else {
(context.cb)( (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() { if (*param).mail_pw.is_null() {
(*param).mail_pw = dc_strdup(0 as *const libc::c_char) (*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.cb)(
context, context,
Event::CONFIGURE_PROGRESS, 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 = param_autoconfig =
moz_autoconfigure(context, url, param); moz_autoconfigure(context, url, param);
free(url as *mut libc::c_void); 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; current_block = 2927484062889439186;
} else { } else {
(context.cb)( (context.cb)(
@@ -337,7 +368,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
param_autoconfig = param_autoconfig =
moz_autoconfigure(context, url_0, param); moz_autoconfigure(context, url_0, param);
free(url_0 as *mut libc::c_void); 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; current_block = 2927484062889439186;
} else { } else {
(context.cb)( (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, context, url_1, param,
); );
free(url_1 as *mut libc::c_void); 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 = current_block =
2927484062889439186; 2927484062889439186;
break; break;
@@ -442,8 +483,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
free( free(
url_2 as *mut libc::c_void, url_2 as *mut libc::c_void,
); );
if 0 != context if 0 != *context
.shall_stop_ongoing .shall_stop_ongoing
.clone()
.read()
.unwrap()
{ {
current_block = current_block =
2927484062889439186; 2927484062889439186;
@@ -500,8 +544,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
free(url_3 free(url_3
as as
*mut libc::c_void); *mut libc::c_void);
if 0 != context if 0 != *context
.shall_stop_ongoing .shall_stop_ongoing
.clone()
.read()
.unwrap()
{ {
current_block 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); *mut libc::c_void);
if 0 if 0
!= !=
context.shall_stop_ongoing *context.shall_stop_ongoing.clone().read().unwrap()
{ {
current_block 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 b"Account settings incomplete.\x00" as *const u8
as *const libc::c_char, 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.cb)(
context, context,
Event::CONFIGURE_PROGRESS, Event::CONFIGURE_PROGRESS,
@@ -832,7 +885,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
break; break;
} }
// probe STARTTLS/993 // probe STARTTLS/993
if 0 != context.shall_stop_ongoing { if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block = 2927484062889439186; current_block = 2927484062889439186;
break; break;
} }
@@ -876,7 +934,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
break; break;
} }
// probe STARTTLS/143 // probe STARTTLS/143
if 0 != context.shall_stop_ongoing { if 0 != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{
current_block = 2927484062889439186; current_block = 2927484062889439186;
break; break;
} }
@@ -922,7 +985,12 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
break; break;
} }
// next probe round with only the localpart of the email-address as the loginname // 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; current_block = 2927484062889439186;
break; break;
} }
@@ -963,7 +1031,13 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
2927484062889439186 => {} 2927484062889439186 => {}
_ => { _ => {
imap_connected_here = 1i32; imap_connected_here = 1i32;
if !(0 != context.shall_stop_ongoing) { if !(0
!= *context
.shall_stop_ongoing
.clone()
.read()
.unwrap())
{
(context.cb)( (context.cb)(
context, context,
Event::CONFIGURE_PROGRESS, 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 */ /* 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( if 0 == dc_smtp_connect(
context,
&mut context &mut context
.smtp .smtp
.clone() .clone()
@@ -990,7 +1065,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
current_block = current_block =
2927484062889439186; 2927484062889439186;
} else if 0 } else if 0
!= context.shall_stop_ongoing != *context
.shall_stop_ongoing
.clone()
.read()
.unwrap()
{ {
current_block = current_block =
2927484062889439186; 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); free(r_3 as *mut libc::c_void);
if 0 == dc_smtp_connect( if 0 == dc_smtp_connect(
context,
&mut context &mut context
.smtp .smtp
.clone() .clone()
@@ -1036,8 +1116,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
.unwrap(), .unwrap(),
param, param,
) { ) {
if 0 != context if 0 != *context
.shall_stop_ongoing .shall_stop_ongoing
.clone()
.read()
.unwrap()
{ {
current_block = current_block =
2927484062889439186; 2927484062889439186;
@@ -1087,6 +1170,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
as as
*mut libc::c_void); *mut libc::c_void);
if 0 == dc_smtp_connect( if 0 == dc_smtp_connect(
context,
&mut context &mut context
.smtp .smtp
.clone() .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; smtp_connected_here = 1i32;
if !(0 if !(0
!= context != *context
.shall_stop_ongoing) .shall_stop_ongoing
.clone()
.read()
.unwrap())
{ {
(context.cb)(context, (context.cb)(context,
Event::CONFIGURE_PROGRESS, 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 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" b"mvbox_watch\x00"
as as
*const u8 *const u8
@@ -1153,7 +1240,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
|| ||
0 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" b"mvbox_move\x00"
as as
*const u8 *const u8
@@ -1175,8 +1262,11 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
flags, flags,
); );
if !(0 if !(0
!= context != *context
.shall_stop_ongoing) .shall_stop_ongoing
.clone()
.read()
.unwrap())
{ {
(context.cb)(context, (context.cb)(context,
Event::CONFIGURE_PROGRESS, Event::CONFIGURE_PROGRESS,
@@ -1198,22 +1288,25 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &dc_context_t, _job: *mut
0i32 0i32
as as
uintptr_t); uintptr_t);
dc_loginparam_write(param, dc_loginparam_write(context, param,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"configured_\x00" b"configured_\x00"
as as
*const u8 *const u8
as as
*const libc::c_char); *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" b"configured\x00"
as as
*const u8 *const u8
as as
*const libc::c_char, *const libc::c_char,
1i32); 1i32);
if !(0 != context if !(0 != *context
.shall_stop_ongoing) .shall_stop_ongoing
.clone()
.read()
.unwrap())
{ {
(context.cb)(context, (context.cb)(context,
Event::CONFIGURE_PROGRESS, 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); *const libc::c_char);
if !(0 if !(0
!= !=
context.shall_stop_ongoing) *context.shall_stop_ongoing.clone().read().unwrap())
{ {
(context.cb)(context, (context.cb)(context,
Event::CONFIGURE_PROGRESS, 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) { pub unsafe fn dc_free_ongoing(mut context: &dc_context_t) {
context.ongoing_running = 0i32; // FIXME
context.shall_stop_ongoing = 1i32; // context.ongoing_running = 0i32;
*context.shall_stop_ongoing.clone().write().unwrap() = 1;
} }
pub unsafe fn dc_configure_folders( pub unsafe fn dc_configure_folders(
context: &dc_context_t, context: &dc_context_t,
imap: &mut dc_imap_t, imap: &mut dc_imap_t,
@@ -1409,6 +1504,7 @@ pub unsafe fn dc_configure_folders(
mailimap_subscribe((*imap).etpan, mvbox_folder); mailimap_subscribe((*imap).etpan, mvbox_folder);
} }
dc_sqlite3_set_config_int( dc_sqlite3_set_config_int(
context,
&mut context.sql.lock().unwrap(), &mut context.sql.lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char, b"folders_configured\x00" as *const u8 as *const libc::c_char,
3i32, 3i32,
@@ -2067,10 +2163,12 @@ pub unsafe fn dc_alloc_ongoing(context: &dc_context_t) -> libc::c_int {
); );
return 0i32; return 0i32;
} }
context.ongoing_running = 1i32; // FIXME
context.shall_stop_ongoing = 0i32; // context.ongoing_running = 1i32;
*context.shall_stop_ongoing.clone().write().unwrap() = 0;
return 1i32; return 1i32;
} }
pub unsafe fn dc_connect_to_configured_imap( pub unsafe fn dc_connect_to_configured_imap(
context: &dc_context_t, context: &dc_context_t,
imap: &mut dc_imap_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) { if 0 != dc_imap_is_connected(imap) {
ret_connected = 1i32 ret_connected = 1i32
} else if dc_sqlite3_get_config_int( } else if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured\x00" as *const u8 as *const libc::c_char, b"configured\x00" as *const u8 as *const libc::c_char,
0i32, 0i32,
@@ -2092,6 +2191,7 @@ pub unsafe fn dc_connect_to_configured_imap(
); );
} else { } else {
dc_loginparam_read( dc_loginparam_read(
context,
param, param,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char, 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) { pub unsafe fn dc_marknoticed_contact(context: &dc_context_t, contact_id: uint32_t) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET state=13 WHERE from_id=? AND state=10;\x00" as *const u8 b"UPDATE msgs SET state=13 WHERE from_id=? AND state=10;\x00" as *const u8
as *const libc::c_char, 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) { if !(addr.is_null() || *addr.offset(0isize) as libc::c_int == 0i32) {
addr_normalized = dc_addr_normalize(addr); addr_normalized = dc_addr_normalize(addr);
addr_self = dc_sqlite3_get_config( addr_self = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\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 contact_id = 1i32
} else { } else {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_text( sqlite3_bind_text(
@@ -165,6 +168,7 @@ pub unsafe fn dc_block_contact(
) && (*contact).blocked != new_blocking ) && (*contact).blocked != new_blocking
{ {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"UPDATE contacts SET blocked=? WHERE id=?;\x00" as *const u8 b"UPDATE contacts SET blocked=? WHERE id=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -177,7 +181,8 @@ pub unsafe fn dc_block_contact(
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
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" b"UPDATE chats SET blocked=? WHERE type=? AND id IN (SELECT chat_id FROM chats_contacts WHERE contact_id=?);\x00"
as *const u8 as as *const u8 as
*const libc::c_char); *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 are verified and known not to be spam */
/* contacts with at least this origin value start a new "normal" chat, defaults to off */ /* contacts with at least this origin value start a new "normal" chat, defaults to off */
pub unsafe fn dc_contact_load_from_db( pub unsafe fn dc_contact_load_from_db(
mut contact: *mut dc_contact_t, contact: *mut dc_contact_t,
mut sql: &mut dc_sqlite3_t, sql: &mut dc_sqlite3_t,
mut contact_id: uint32_t, contact_id: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut current_block: u64; let mut current_block: u64;
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
@@ -296,6 +301,7 @@ pub unsafe fn dc_contact_load_from_db(
(*contact).id = contact_id; (*contact).id = contact_id;
(*contact).name = dc_stock_str((*contact).context, 2i32); (*contact).name = dc_stock_str((*contact).context, 2i32);
(*contact).addr = dc_sqlite3_get_config( (*contact).addr = dc_sqlite3_get_config(
(*contact).context,
sql, sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\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; current_block = 5143058163439228106;
} else { } else {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, contact_id as libc::c_int); 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) { if !(addr__.is_null() || origin <= 0i32) {
addr = dc_addr_normalize(addr__); addr = dc_addr_normalize(addr__);
addr_self = dc_sqlite3_get_config( addr_self = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\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 { } else {
stmt = 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" b"SELECT id, name, addr, origin, authname FROM contacts WHERE addr=? COLLATE NOCASE;\x00"
as *const u8 as *const libc::c_char); as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, addr as *const libc::c_char, -1i32, None); 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 || origin > row_origin
{ {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"UPDATE contacts SET name=?, addr=?, origin=?, authname=? WHERE id=?;\x00" b"UPDATE contacts SET name=?, addr=?, origin=?, authname=? WHERE id=?;\x00"
as *const u8 as *const libc::c_char, 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; stmt = 0 as *mut sqlite3_stmt;
if 0 != update_name { if 0 != update_name {
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 name=? WHERE type=? AND id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?);\x00" b"UPDATE chats SET name=? WHERE type=? AND id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?);\x00"
as *const u8 as as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -485,6 +496,7 @@ pub unsafe fn dc_add_or_lookup_contact(
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"INSERT INTO contacts (name, addr, origin) VALUES(?, ?, ?);\x00" as *const u8 b"INSERT INTO contacts (name, addr, origin) VALUES(?, ?, ?);\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -504,6 +516,7 @@ pub unsafe fn dc_add_or_lookup_contact(
sqlite3_bind_int(stmt, 3i32, origin); sqlite3_bind_int(stmt, 3i32, origin);
if sqlite3_step(stmt) == 101i32 { if sqlite3_step(stmt) == 101i32 {
row_id = dc_sqlite3_get_rowid( row_id = dc_sqlite3_get_rowid(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"contacts\x00" as *const u8 as *const libc::c_char, b"contacts\x00" as *const u8 as *const libc::c_char,
b"addr\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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
self_addr = dc_sqlite3_get_config( self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\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; current_block = 7597307149762829253;
} else { } else {
stmt = 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" 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 as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -652,6 +667,7 @@ pub unsafe fn dc_get_contacts(
}, },
); );
self_name = dc_sqlite3_get_config( self_name = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"displayname\x00" as *const u8 as *const libc::c_char, b"displayname\x00" as *const u8 as *const libc::c_char,
b"\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 { } else {
stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, self_addr, -1i32, None); 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0\x00" as *const u8 b"SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0\x00" as *const u8
as *const libc::c_char, 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM contacts WHERE id>? AND blocked!=0 ORDER BY LOWER(name||addr),id;\x00" 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, as *const u8 as *const libc::c_char,
@@ -771,11 +790,13 @@ pub unsafe fn dc_get_contact_encrinfo(
(*contact).addr, (*contact).addr,
); );
dc_loginparam_read( dc_loginparam_read(
context,
loginparam, loginparam,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char, b"configured_\x00" as *const u8 as *const libc::c_char,
); );
dc_key_load_self_public( dc_key_load_self_public(
context,
self_key, self_key,
(*loginparam).addr, (*loginparam).addr,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
@@ -794,6 +815,7 @@ pub unsafe fn dc_get_contact_encrinfo(
if (*self_key).binary.is_null() { if (*self_key).binary.is_null() {
dc_ensure_secret_key_exists(context); dc_ensure_secret_key_exists(context);
dc_key_load_self_public( dc_key_load_self_public(
context,
self_key, self_key,
(*loginparam).addr, (*loginparam).addr,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
@@ -804,11 +826,11 @@ pub unsafe fn dc_get_contact_encrinfo(
dc_strbuilder_cat(&mut ret, p); dc_strbuilder_cat(&mut ret, p);
free(p as *mut libc::c_void); free(p as *mut libc::c_void);
dc_strbuilder_cat(&mut ret, b":\x00" as *const u8 as *const libc::c_char); 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 = 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 = 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 { if strcmp((*loginparam).addr, (*peerstate).addr) < 0i32 {
cat_fingerprint( cat_fingerprint(
&mut ret, &mut ret,
@@ -900,6 +922,7 @@ pub unsafe fn dc_delete_contact(
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !contact_id <= 9i32 as libc::c_uint { if !contact_id <= 9i32 as libc::c_uint {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;\x00" as *const u8 b"SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -909,6 +932,7 @@ pub unsafe fn dc_delete_contact(
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;\x00" as *const u8 b"SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -919,6 +943,7 @@ pub unsafe fn dc_delete_contact(
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"DELETE FROM contacts WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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; return (*contact).blocked;
} }
pub unsafe fn dc_contact_is_verified(mut contact: *mut dc_contact_t) -> libc::c_int { 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>( pub unsafe fn dc_contact_is_verified_ex<'a>(
contact: *mut dc_contact_t<'a>, contact: *mut dc_contact_t<'a>,
peerstate: *const dc_apeerstate_t<'a>, mut peerstate: *mut dc_apeerstate_t<'a>,
) -> libc::c_int { ) -> libc::c_int {
let mut current_block: u64; let mut current_block: u64;
let mut contact_verified: libc::c_int = 0i32; let mut contact_verified: libc::c_int = 0i32;
@@ -1108,6 +1133,7 @@ pub unsafe fn dc_addr_equals_self(
if !addr.is_null() { if !addr.is_null() {
normalized_addr = dc_addr_normalize(addr); normalized_addr = dc_addr_normalize(addr);
self_addr = dc_sqlite3_get_config( self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !context.sql.clone().lock().unwrap().cobj.is_null() { if !context.sql.clone().lock().unwrap().cobj.is_null() {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM contacts WHERE id>?;\x00" as *const u8 as *const libc::c_char, 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; let mut ret: libc::c_int = 0i32;
if !(context.sql.clone().lock().unwrap().cobj.is_null() || contact_id <= 9i32 as libc::c_uint) { if !(context.sql.clone().lock().unwrap().cobj.is_null() || contact_id <= 9i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM contacts WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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, mut origin: libc::c_int,
) { ) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"UPDATE contacts SET origin=? WHERE id=? AND origin<?;\x00" as *const u8 b"UPDATE contacts SET origin=? WHERE id=? AND origin<?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,

123
src/dc_context.rs
View File

@@ -1,6 +1,5 @@
use libc; use libc;
use std::sync::{Arc, Condvar, Mutex, RwLock}; use std::sync::{Arc, Condvar, Mutex, RwLock};
use std::time::SystemTime;
use crate::constants::VERSION; use crate::constants::VERSION;
use crate::dc_array::*; use crate::dc_array::*;
@@ -33,20 +32,38 @@ pub struct dc_context_t {
pub inbox: Arc<Mutex<dc_imap_t>>, pub inbox: Arc<Mutex<dc_imap_t>>,
pub perform_inbox_jobs_needed: Arc<RwLock<i32>>, pub perform_inbox_jobs_needed: Arc<RwLock<i32>>,
pub probe_imap_network: Arc<RwLock<i32>>, pub probe_imap_network: Arc<RwLock<i32>>,
pub sentbox_thread: dc_jobthread_t, pub sentbox_thread: Arc<Mutex<dc_jobthread_t>>,
pub mvbox_thread: dc_jobthread_t, pub mvbox_thread: Arc<Mutex<dc_jobthread_t>>,
pub smtp: Arc<Mutex<dc_smtp_t>>, pub smtp: Arc<Mutex<dc_smtp_t>>,
pub smtp_state: Arc<(Mutex<SmtpState>, Condvar)>, pub smtp_state: Arc<(Mutex<SmtpState>, Condvar)>,
pub oauth2_critical: Arc<Mutex<()>>, pub oauth2_critical: Arc<Mutex<()>>,
pub cb: dc_callback_t, pub cb: dc_callback_t,
pub os_name: *mut libc::c_char, pub os_name: *mut libc::c_char,
pub cmdline_sel_chat_id: u32, pub cmdline_sel_chat_id: u32,
pub bob_expects: i32, pub bob: Arc<RwLock<BobStatus>>,
pub bobs_status: i32, pub last_smeared_timestamp: Arc<RwLock<time_t>>,
pub bobs_qr_scan: Arc<RwLock<*mut dc_lot_t>>,
pub last_smeared_timestamp: Arc<RwLock<Option<SystemTime>>>,
pub ongoing_running: i32, 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)] #[derive(Default, Debug)]
@@ -93,19 +110,17 @@ pub fn dc_context_new(
})), })),
userdata, userdata,
cb, cb,
os_name: dc_strdup_keep_null(os_name), os_name: unsafe { dc_strdup_keep_null(os_name) },
ongoing_running: 0, ongoing_running: 0,
shall_stop_ongoing: 1, shall_stop_ongoing: Arc::new(RwLock::new(1)),
sql: Arc::new(Mutex::new(dc_sqlite3_new())), sql: Arc::new(Mutex::new(dc_sqlite3_new())),
smtp: Arc::new(Mutex::new(dc_smtp_new())), smtp: Arc::new(Mutex::new(dc_smtp_new())),
smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())), smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
oauth2_critical: Arc::new(Mutex::new(())), oauth2_critical: Arc::new(Mutex::new(())),
bob_expects: 0, bob: Arc::new(RwLock::new(Default::default())),
bobs_status: 0, last_smeared_timestamp: Arc::new(RwLock::new(0 as time_t)),
bobs_qr_scan: Arc::new(RwLock::new(std::ptr::null_mut())),
last_smeared_timestamp: Arc::new(RwLock::new(None)),
cmdline_sel_chat_id: 0, cmdline_sel_chat_id: 0,
sentbox_thread: unsafe { sentbox_thread: Arc::new(Mutex::new(unsafe {
dc_jobthread_init( dc_jobthread_init(
b"SENTBOX\x00" as *const u8 as *const libc::c_char, b"SENTBOX\x00" as *const u8 as *const libc::c_char,
b"configured_sentbox_folder\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), Some(cb_receive_imf),
), ),
) )
}, })),
mvbox_thread: unsafe { mvbox_thread: Arc::new(Mutex::new(unsafe {
dc_jobthread_init( dc_jobthread_init(
b"MVBOX\x00" as *const u8 as *const libc::c_char, b"MVBOX\x00" as *const u8 as *const libc::c_char,
b"configured_mvbox_folder\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), Some(cb_receive_imf),
), ),
) )
}, })),
probe_imap_network: Arc::new(RwLock::new(0)), probe_imap_network: Arc::new(RwLock::new(0)),
perform_inbox_jobs_needed: 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, key: *const libc::c_char,
def: *const libc::c_char, def: *const libc::c_char,
) -> *mut 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) { 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.inbox.clone().lock().unwrap());
dc_imap_unref( dc_imap_unref(
context, context,
&mut context.sentbox_thread.imap.clone().lock().unwrap(), &mut context
.sentbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
); );
dc_imap_unref( dc_imap_unref(
context, 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_smtp_unref(&mut context.smtp.clone().lock().unwrap());
dc_sqlite3_unref(context, &mut context.sql.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.sentbox_thread.clone().lock().unwrap());
dc_jobthread_exit(&mut context.mvbox_thread); dc_jobthread_exit(&mut context.mvbox_thread.clone().lock().unwrap());
free(context.os_name as *mut libc::c_void); 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.inbox.clone().lock().unwrap());
dc_imap_disconnect( dc_imap_disconnect(
context, context,
&mut context.sentbox_thread.imap.clone().lock().unwrap(), &mut context
.sentbox_thread
.clone()
.lock()
.unwrap()
.imap
.clone()
.lock()
.unwrap(),
); );
dc_imap_disconnect( dc_imap_disconnect(
context, 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()); 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 { 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( let mut rel_path: *mut libc::c_char = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
key, key,
0 as *const libc::c_char, 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 { } else {
value = dc_sqlite3_get_config( value = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
key, key,
0 as *const libc::c_char, 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(); l = dc_loginparam_new();
l2 = dc_loginparam_new(); l2 = dc_loginparam_new();
dc_loginparam_read( dc_loginparam_read(
context,
l, l,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"\x00" as *const u8 as *const libc::c_char, b"\x00" as *const u8 as *const libc::c_char,
); );
dc_loginparam_read( dc_loginparam_read(
context,
l2, l2,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char, b"configured_\x00" as *const u8 as *const libc::c_char,
); );
displayname = dc_sqlite3_get_config( displayname = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"displayname\x00" as *const u8 as *const libc::c_char, b"displayname\x00" as *const u8 as *const libc::c_char,
0 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; deaddrop_msgs = dc_get_deaddrop_msg_cnt(context) as libc::c_int;
contacts = dc_get_real_contact_cnt(context) as libc::c_int; contacts = dc_get_real_contact_cnt(context) as libc::c_int;
is_configured = dc_sqlite3_get_config_int( is_configured = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured\x00" as *const u8 as *const libc::c_char, b"configured\x00" as *const u8 as *const libc::c_char,
0, 0,
); );
dbversion = dc_sqlite3_get_config_int( dbversion = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"dbversion\x00" as *const u8 as *const libc::c_char, b"dbversion\x00" as *const u8 as *const libc::c_char,
0, 0,
); );
e2ee_enabled = dc_sqlite3_get_config_int( e2ee_enabled = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char, b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1, 1,
); );
mdns_enabled = dc_sqlite3_get_config_int( mdns_enabled = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char, b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1, 1,
); );
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM keypairs;\x00" as *const u8 as *const libc::c_char, 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); prv_key_cnt = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM acpeerstates;\x00" as *const u8 as *const libc::c_char, 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); pub_key_cnt = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
if 0 != dc_key_load_self_public( if 0 != dc_key_load_self_public(
context,
self_public, self_public,
(*l2).addr, (*l2).addr,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
) { ) {
fingerprint_str = dc_key_get_fingerprint(self_public) fingerprint_str = dc_key_get_fingerprint(context, self_public)
} else { } else {
fingerprint_str = dc_strdup(b"<Not yet calculated>\x00" as *const u8 as *const libc::c_char) 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); l_readable_str = dc_loginparam_get_readable(l);
l2_readable_str = dc_loginparam_get_readable(l2); l2_readable_str = dc_loginparam_get_readable(l2);
inbox_watch = dc_sqlite3_get_config_int( inbox_watch = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"inbox_watch\x00" as *const u8 as *const libc::c_char, b"inbox_watch\x00" as *const u8 as *const libc::c_char,
1, 1,
); );
sentbox_watch = dc_sqlite3_get_config_int( sentbox_watch = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char, b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1, 1,
); );
mvbox_watch = dc_sqlite3_get_config_int( mvbox_watch = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char, b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1, 1,
); );
mvbox_move = dc_sqlite3_get_config_int( mvbox_move = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"mvbox_move\x00" as *const u8 as *const libc::c_char, b"mvbox_move\x00" as *const u8 as *const libc::c_char,
1, 1,
); );
folders_configured = dc_sqlite3_get_config_int( folders_configured = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char, b"folders_configured\x00" as *const u8 as *const libc::c_char,
0, 0,
); );
configured_sentbox_folder = dc_sqlite3_get_config( configured_sentbox_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char, b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
b"<unset>\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( configured_mvbox_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char, b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
b"<unset>\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; let mut stmt = 0 as *mut sqlite3_stmt;
if !ret.is_null() { if !ret.is_null() {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT m.id FROM msgs m LEFT JOIN contacts ct \ 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=? \ 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); strLikeBeg = dc_mprintf(b"%s%%\x00" as *const u8 as *const libc::c_char, real_query);
if 0 != chat_id { if 0 != chat_id {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &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=? \ 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 \ AND m.hidden=0 \
@@ -901,6 +969,7 @@ pub unsafe fn dc_search_msgs(
} else { } else {
let mut show_deaddrop = 0; let mut show_deaddrop = 0;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &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 \ 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 \ 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, folder_name: *const libc::c_char,
) -> libc::c_int { ) -> libc::c_int {
let mut sentbox_name = dc_sqlite3_get_config( let mut sentbox_name = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char, b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
0 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 { 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( let mut mvbox_name = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char, b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 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. */ /* 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; (*autocryptheader).prefer_encrypt = 0i32;
if 0 != dc_sqlite3_get_config_int( if 0 != dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char, b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32, 1i32,
@@ -81,6 +82,7 @@ pub unsafe fn dc_e2ee_encrypt(
(*autocryptheader).prefer_encrypt = 1i32 (*autocryptheader).prefer_encrypt = 1i32
} }
(*autocryptheader).addr = dc_sqlite3_get_config( (*autocryptheader).addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 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 { if 0 != do_encrypt {
dc_keyring_add(keyring, (*autocryptheader).public_key); dc_keyring_add(keyring, (*autocryptheader).public_key);
if 0 == dc_key_load_self_private( if 0 == dc_key_load_self_private(
context,
sign_key, sign_key,
(*autocryptheader).addr, (*autocryptheader).addr,
&mut context.sql.clone().lock().unwrap(), &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; let mut key_creation_here: libc::c_int = 0i32;
if !public_key.is_null() { if !public_key.is_null() {
if 0 == dc_key_load_self_public( if 0 == dc_key_load_self_public(
context,
public_key, public_key,
self_addr, self_addr,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
@@ -574,6 +578,7 @@ unsafe fn load_or_generate_self_public_key(
current_block = 10496152961502316708; current_block = 10496152961502316708;
} else if 0 } else if 0
== dc_key_save_self_keypair( == dc_key_save_self_keypair(
context,
public_key, public_key,
private_key, private_key,
self_addr, self_addr,
@@ -699,6 +704,7 @@ pub unsafe fn dc_e2ee_decrypt(
} }
/* load private key for decryption */ /* load private key for decryption */
self_addr = dc_sqlite3_get_config( self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 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 !self_addr.is_null() {
if !(0 if !(0
== dc_keyring_load_self_private_for_decrypting( == dc_keyring_load_self_private_for_decrypting(
context,
private_keyring, private_keyring,
self_addr, self_addr,
&mut context.sql.clone().lock().unwrap(), &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; let mut self_addr: *mut libc::c_char = 0 as *mut libc::c_char;
if !public_key.is_null() { if !public_key.is_null() {
self_addr = dc_sqlite3_get_config( self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char, b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 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; }) as time_t;
// FIXME // FIXME
// pthread_mutex_lock(&mut imap.watch_condmutex); // pthread_mutex_lock(&mut imap.watch_condmutex);
let mut r: libc::c_int = 0;
let mut wakeup_at: timespec = timespec { let mut wakeup_at: timespec = timespec {
tv_sec: 0, tv_sec: 0,
tv_nsec: 0, tv_nsec: 0,
@@ -1746,7 +1745,7 @@ pub unsafe fn dc_imap_delete_msg(
imap: &mut dc_imap_t, imap: &mut dc_imap_t,
rfc724_mid: *const libc::c_char, rfc724_mid: *const libc::c_char,
folder: *const libc::c_char, folder: *const libc::c_char,
server_uid: uint32_t, mut server_uid: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0; let mut success: libc::c_int = 0;
let mut r: libc::c_int = 0; let mut r: libc::c_int = 0;

36
src/dc_imex.rs
View File

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

172
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( unsafe fn dc_job_perform(
mut context: &dc_context_t, context: &dc_context_t,
mut thread: libc::c_int, mut thread: libc::c_int,
mut probe_network: libc::c_int, mut probe_network: libc::c_int,
) { ) {
@@ -90,14 +90,18 @@ unsafe fn dc_job_perform(
if probe_network == 0i32 { if probe_network == 0i32 {
select_stmt = select_stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(), 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64); 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); sqlite3_bind_int64(select_stmt, 2i32, time(0 as *mut time_t) as sqlite3_int64);
} else { } else {
select_stmt = select_stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(), 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64); 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); dc_job_kill_action(context, job.action);
sqlite3_finalize(select_stmt); sqlite3_finalize(select_stmt);
select_stmt = 0 as *mut sqlite3_stmt; select_stmt = 0 as *mut sqlite3_stmt;
dc_jobthread_suspend(&mut context.sentbox_thread, 1i32); dc_jobthread_suspend(
dc_jobthread_suspend(&mut context.mvbox_thread, 1i32); 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); dc_suspend_smtp_thread(context, 1i32);
} }
let mut tries: libc::c_int = 0i32; let mut tries: libc::c_int = 0i32;
@@ -178,8 +190,16 @@ unsafe fn dc_job_perform(
tries += 1 tries += 1
} }
if 900i32 == job.action || 910i32 == job.action { if 900i32 == job.action || 910i32 == job.action {
dc_jobthread_suspend(&mut context.sentbox_thread, 0i32); dc_jobthread_suspend(
dc_jobthread_suspend(&mut context.mvbox_thread, 0i32); 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); dc_suspend_smtp_thread(context, 0i32);
break; break;
} else if job.try_again == 2i32 { } 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) { 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( let mut delete_stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"DELETE FROM jobs WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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) { 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( let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"UPDATE jobs SET desired_timestamp=?, tries=?, param=? WHERE id=?;\x00" as *const u8 b"UPDATE jobs SET desired_timestamp=?, tries=?, param=? WHERE id=?;\x00" as *const u8
as *const libc::c_char, 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()) { if 0 == dc_smtp_is_connected(&context.smtp.clone().lock().unwrap()) {
let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new(); let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new();
dc_loginparam_read( dc_loginparam_read(
context,
loginparam, loginparam,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char, b"configured_\x00" as *const u8 as *const libc::c_char,
); );
let mut connected: libc::c_int = let mut connected: libc::c_int = dc_smtp_connect(
dc_smtp_connect(&mut context.smtp.clone().lock().unwrap(), loginparam); context,
&mut context.smtp.clone().lock().unwrap(),
loginparam,
);
dc_loginparam_unref(loginparam); dc_loginparam_unref(loginparam);
if 0 == connected { if 0 == connected {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char); 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 */ /* send message */
if 0 == dc_smtp_send_msg( if 0 == dc_smtp_send_msg(
context,
&mut context.smtp.clone().lock().unwrap(), &mut context.smtp.clone().lock().unwrap(),
recipients_list, recipients_list,
buf as *const libc::c_char, 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 { if 0 != (*job).foreign_id {
dc_update_msg_state(context, (*job).foreign_id, 26i32); dc_update_msg_state(context, (*job).foreign_id, 26i32);
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT chat_id FROM msgs WHERE id=?\x00" as *const u8 b"SELECT chat_id FROM msgs WHERE id=?\x00" as *const u8
as *const libc::c_char, 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 => { 2473556513754201174 => {
if !(0 == dc_msg_load_from_db(msg, context, (*job).foreign_id)) { if !(0 == dc_msg_load_from_db(msg, context, (*job).foreign_id)) {
if dc_sqlite3_get_config_int( if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char, b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32, 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( dest_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char, b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 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 0 != dc_param_get_int((*job).param, 'M' as i32, 0i32) {
if dc_sqlite3_get_config_int( if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char, b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32, 0i32,
@@ -596,6 +627,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(
); );
} }
dest_folder = dc_sqlite3_get_config( dest_folder = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char, b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 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) if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != dc_sqlite3_get_config_int( && 0 != dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char, b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32, 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) if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != dc_sqlite3_get_config_int( && 0 != dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char, b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32, 1i32,
@@ -894,7 +928,9 @@ pub unsafe fn dc_job_add(
return; return;
} }
stmt = stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(), 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" b"INSERT INTO jobs (added_timestamp, thread, action, foreign_id, param, desired_timestamp) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char); as *const u8 as *const libc::c_char);
sqlite3_bind_int64(stmt, 1i32, timestamp as sqlite3_int64); sqlite3_bind_int64(stmt, 1i32, timestamp as sqlite3_int64);
@@ -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 &(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.perform_jobs_needed = 1;
state.idle = true; 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 */ /* 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) { pub unsafe fn dc_job_kill_action(mut context: &dc_context_t, mut action: libc::c_int) {
let mut stmt = dc_sqlite3_prepare( let mut stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"DELETE FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char, 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; return;
} }
if dc_sqlite3_get_config_int( if dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"inbox_watch\x00" as *const u8 as *const libc::c_char, b"inbox_watch\x00" as *const u8 as *const libc::c_char,
1i32, 1i32,
@@ -1046,14 +1084,14 @@ pub unsafe fn dc_perform_imap_fetch(mut context: &dc_context_t) {
0i32, 0i32,
b"INBOX-fetch started...\x00" as *const u8 as *const libc::c_char, 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 { if 0 != context.inbox.clone().lock().unwrap().should_reconnect {
dc_log_info( dc_log_info(
context, context,
0i32, 0i32,
b"INBOX-fetch aborted, starting over...\x00" as *const u8 as *const libc::c_char, 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( dc_log_info(
context, 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, 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); 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( dc_log_info(
context, context,
0i32, 0i32,
b"INBOX-IDLE will not be started because of waiting jobs.\x00" as *const u8 b"INBOX-IDLE will not be started because of waiting jobs.\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
drop(l);
return; return;
} }
drop(l);
dc_log_info( dc_log_info(
context, context,
0i32, 0i32,
b"INBOX-IDLE started...\x00" as *const u8 as *const libc::c_char, 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( dc_log_info(
context, context,
0i32, 0i32,
b"INBOX-IDLE ended.\x00" as *const u8 as *const libc::c_char, 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( let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char, b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32, 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( let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char, b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32, 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( let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char, b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32, 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( let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char, b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32, 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 probe_smtp_network = {
let &(ref lock, _) = &*context.smtp_state.clone(); 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; let probe_smtp_network = state.probe_network;
state.probe_network = 0; 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 &(ref lock, _) = &*context.smtp_state.clone();
let state = lock.lock().unwrap(); let mut state = lock.lock().unwrap();
state.doing_jobs = 0; 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, as *const libc::c_char,
); );
} else { } else {
let mut r = false;
// FIXME: correct time based on // FIXME: correct time based on
// get_next_wakeup_time(context, 5000) + 1; // get_next_wakeup_time(context, 5000) + 1;
let dur = Duration::from_milis(5000).unwrap(); let dur = Duration::from_millis(5000);
loop { loop {
let res = cvar.wait_timeout(state, dur); let res = cvar.wait_timeout(state, dur).unwrap();
state = res.0; 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. // We received the notification and the value has been updated, we can leave.
break; 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 wakeup_time: time_t = 0i32 as time_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;\x00" as *const u8 b"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;\x00" as *const u8
as *const libc::c_char, 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 wakeup_time = sqlite3_column_int(stmt, 0i32) as time_t
} }
if wakeup_time == 0i32 as libc::c_long { 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); sqlite3_finalize(stmt);
return wakeup_time; return wakeup_time;
} }
pub unsafe fn dc_maybe_network(mut context: &dc_context_t) { pub unsafe fn dc_maybe_network(mut context: &dc_context_t) {
pthread_mutex_lock(&mut context.smtpidle_condmutex); {
context.probe_smtp_network = 1i32; let &(ref lock, _) = &*context.smtp_state.clone();
pthread_mutex_unlock(&mut context.smtpidle_condmutex); let mut state = lock.lock().unwrap();
let l = context.inboxidle_condmutex.lock().unwrap(); state.probe_network = 1;
context.probe_imap_network = 1i32;
drop(l); *context.probe_imap_network.clone().write().unwrap() = 1;
}
dc_interrupt_smtp_idle(context); dc_interrupt_smtp_idle(context);
dc_interrupt_imap_idle(context); dc_interrupt_imap_idle(context);
dc_interrupt_mvbox_idle(context); dc_interrupt_mvbox_idle(context);
dc_interrupt_sentbox_idle(context); dc_interrupt_sentbox_idle(context);
} }
pub unsafe fn dc_job_action_exists( pub unsafe fn dc_job_action_exists(
mut context: &dc_context_t, mut context: &dc_context_t,
mut action: libc::c_int, mut action: libc::c_int,
) -> libc::c_int { ) -> libc::c_int {
let mut job_exists: libc::c_int = 0i32; 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( stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(), &mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char, 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; return job_exists;
} }
/* special case for DC_JOB_SEND_MSG_TO_SMTP */ /* 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 success: libc::c_int = 0i32;
let mut mimefactory: dc_mimefactory_t = dc_mimefactory_t { let mut mimefactory = dc_mimefactory_t {
from_addr: 0 as &libc::c_char, from_addr: 0 as *mut libc::c_char,
from_displayname: 0 as *mut libc::c_char, from_displayname: 0 as *mut libc::c_char,
selfstatus: 0 as *mut libc::c_char, selfstatus: 0 as *mut libc::c_char,
recipients_names: 0 as *mut clist, 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_gossiped: 0,
out_last_added_location_id: 0, out_last_added_location_id: 0,
error: 0 as *mut libc::c_char, error: 0 as *mut libc::c_char,
context: std::ptr::null_mut(), context,
}; };
dc_mimefactory_init(&mut mimefactory, context); dc_mimefactory_init(&mut mimefactory, context);
/* load message data */ /* 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 == 50i32
|| (*mimefactory.msg).type_0 == 60i32 || (*mimefactory.msg).type_0 == 60i32
{ {
let mut pathNfilename: &libc::c_char = dc_param_get( let mut pathNfilename = dc_param_get(
(*mimefactory.msg).param, (*mimefactory.msg).param,
'f' as i32, 'f' as i32,
0 as *const libc::c_char, 0 as *const libc::c_char,

289
src/dc_jobthread.rs
View File

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

54
src/dc_key.rs
View File

@@ -252,23 +252,25 @@ 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( pub unsafe fn dc_key_save_self_keypair(
mut public_key: *const dc_key_t, context: &dc_context_t,
mut private_key: *const dc_key_t, public_key: *const dc_key_t,
mut addr: *const libc::c_char, private_key: *const dc_key_t,
mut is_default: libc::c_int, addr: *const libc::c_char,
mut sql: &mut dc_sqlite3_t, is_default: libc::c_int,
sql: &mut dc_sqlite3_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(public_key.is_null() if !(public_key.is_null()
|| private_key.is_null() || private_key.is_null()
|| addr.is_null() || addr.is_null()
|| sql.is_null()
|| (*public_key).binary.is_null() || (*public_key).binary.is_null()
|| (*private_key).binary.is_null()) || (*private_key).binary.is_null())
{ {
stmt = stmt =
dc_sqlite3_prepare(sql, dc_sqlite3_prepare(
context,
sql,
b"INSERT INTO keypairs (addr, is_default, public_key, private_key, created) VALUES (?,?,?,?,?);\x00" b"INSERT INTO keypairs (addr, is_default, public_key, private_key, created) VALUES (?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char); as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, addr, -1i32, None); sqlite3_bind_text(stmt, 1i32, addr, -1i32, None);
@@ -290,15 +292,17 @@ pub unsafe fn dc_key_save_self_keypair(
return success; return success;
} }
pub unsafe fn dc_key_load_self_public( pub unsafe fn dc_key_load_self_public(
mut key: *mut dc_key_t, context: &dc_context_t,
mut self_addr: *const libc::c_char, key: *mut dc_key_t,
mut sql: &mut dc_sqlite3_t, self_addr: *const libc::c_char,
sql: &mut dc_sqlite3_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; 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); dc_key_empty(key);
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
sql, sql,
b"SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8 b"SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -313,15 +317,17 @@ pub unsafe fn dc_key_load_self_public(
return success; return success;
} }
pub unsafe fn dc_key_load_self_private( pub unsafe fn dc_key_load_self_private(
mut key: *mut dc_key_t, context: &dc_context_t,
mut self_addr: *const libc::c_char, key: *mut dc_key_t,
mut sql: &mut dc_sqlite3_t, self_addr: *const libc::c_char,
sql: &mut dc_sqlite3_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; 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); dc_key_empty(key);
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
context,
sql, sql,
b"SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8 b"SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -469,7 +475,7 @@ pub unsafe fn dc_key_render_asc_to_file(
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut file_content: *mut libc::c_char = 0 as *mut libc::c_char; 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); file_content = dc_key_render_asc(key, 0 as *const libc::c_char);
if !file_content.is_null() { if !file_content.is_null() {
if 0 == dc_write_file( 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; 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_buf: *mut uint8_t = 0 as *mut uint8_t;
let mut fingerprint_bytes: size_t = 0i32 as size_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; let mut fingerprint_hex: *mut libc::c_char = 0 as *mut libc::c_char;
if !key.is_null() { 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) 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) 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 { pub unsafe fn dc_key_get_formatted_fingerprint(
let mut rawhex: *mut libc::c_char = dc_key_get_fingerprint(key); 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); let mut formatted: *mut libc::c_char = dc_format_fingerprint(rawhex);
free(rawhex as *mut libc::c_void); free(rawhex as *mut libc::c_void);
return formatted; return formatted;

11
src/dc_keyring.rs
View File

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

134
src/dc_location.rs
View File

@@ -51,14 +51,12 @@ pub unsafe fn dc_send_locations_to_chat(
let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t; 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 stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
let mut is_sending_locations_before: libc::c_int = 0i32; let mut is_sending_locations_before: libc::c_int = 0i32;
if !(context.is_null() if !(seconds < 0i32 || chat_id <= 9i32 as libc::c_uint) {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| seconds < 0i32
|| chat_id <= 9i32 as libc::c_uint)
{
is_sending_locations_before = dc_is_sending_locations_to_chat(context, chat_id); is_sending_locations_before = dc_is_sending_locations_to_chat(context, chat_id);
stmt = stmt =
dc_sqlite3_prepare((*context).sql, dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET locations_send_begin=?, locations_send_until=? WHERE id=?\x00" b"UPDATE chats SET locations_send_begin=?, locations_send_until=? WHERE id=?\x00"
as *const u8 as *const libc::c_char); as *const u8 as *const libc::c_char);
sqlite3_bind_int64( sqlite3_bind_int64(
@@ -102,7 +100,7 @@ pub unsafe fn dc_send_locations_to_chat(
); );
dc_add_device_msg(context, chat_id, stock_str); dc_add_device_msg(context, chat_id, stock_str);
} }
((*context).cb)( (context.cb)(
context, context,
Event::CHAT_MODIFIED, Event::CHAT_MODIFIED,
chat_id as uintptr_t, chat_id as uintptr_t,
@@ -137,11 +135,12 @@ pub unsafe extern "C" fn dc_is_sending_locations_to_chat(
) -> libc::c_int { ) -> libc::c_int {
let mut is_sending_locations: libc::c_int = 0i32; let mut is_sending_locations: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; 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( stmt = dc_sqlite3_prepare(
(*context).sql, context,
b"SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;\x00" &mut context.sql.clone().lock().unwrap(),
as *const u8 as *const libc::c_char, b"SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;\x00" as *const u8
as *const libc::c_char,
); );
sqlite3_bind_int( sqlite3_bind_int(
stmt, stmt,
@@ -157,7 +156,7 @@ pub unsafe extern "C" fn dc_is_sending_locations_to_chat(
if !(sqlite3_step(stmt) != 100i32) { if !(sqlite3_step(stmt) != 100i32) {
is_sending_locations = 1i32 is_sending_locations = 1i32
} }
}
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
return is_sending_locations; 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_chats: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut stmt_insert: *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; let mut continue_streaming: libc::c_int = 0i32;
if context.is_null() if latitude == 0.0f64 && longitude == 0.0f64 {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| latitude == 0.0f64 && longitude == 0.0f64
{
continue_streaming = 1i32 continue_streaming = 1i32
} else { } else {
stmt_chats = dc_sqlite3_prepare( 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 b"SELECT id FROM chats WHERE locations_send_until>?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
@@ -185,7 +182,9 @@ pub unsafe fn dc_set_location(
while sqlite3_step(stmt_chats) == 100i32 { while sqlite3_step(stmt_chats) == 100i32 {
let mut chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t; let mut chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
stmt_insert = stmt_insert =
dc_sqlite3_prepare((*context).sql, dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO locations (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);\x00" b"INSERT INTO locations (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char); as *const u8 as *const libc::c_char);
sqlite3_bind_double(stmt_insert, 1i32, latitude); sqlite3_bind_double(stmt_insert, 1i32, latitude);
@@ -198,7 +197,7 @@ pub unsafe fn dc_set_location(
continue_streaming = 1i32 continue_streaming = 1i32
} }
if 0 != continue_streaming { if 0 != continue_streaming {
((*context).cb)( (context.cb)(
context, context,
Event::LOCATION_CHANGED, Event::LOCATION_CHANGED,
1i32 as uintptr_t, 1i32 as uintptr_t,
@@ -218,14 +217,15 @@ pub unsafe fn dc_get_locations(
mut timestamp_from: time_t, mut timestamp_from: time_t,
mut timestamp_to: time_t, mut timestamp_to: time_t,
) -> *mut dc_array_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; 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 { if timestamp_to == 0i32 as libc::c_long {
timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long
} }
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent \ b"SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent \
m.id, l.from_id, l.chat_id, m.txt \ 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=?) \ FROM locations l LEFT JOIN msgs m ON l.id=m.location_id WHERE (? OR l.chat_id=?) \
@@ -281,7 +281,7 @@ pub unsafe fn dc_get_locations(
} }
dc_array_add_ptr(ret, loc as *mut libc::c_void); dc_array_add_ptr(ret, loc as *mut libc::c_void);
} }
}
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
return ret; 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) { pub unsafe fn dc_delete_all_locations(mut context: &dc_context_t) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; 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( stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM locations;\x00" as *const u8 as *const libc::c_char, b"DELETE FROM locations;\x00" as *const u8 as *const libc::c_char,
); );
sqlite3_step(stmt); sqlite3_step(stmt);
((*context).cb)( (context.cb)(
context, context,
Event::LOCATION_CHANGED, Event::LOCATION_CHANGED,
0i32 as uintptr_t, 0i32 as uintptr_t,
0i32 as uintptr_t, 0i32 as uintptr_t,
); );
}
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
} }
pub unsafe fn dc_get_location_kml( pub unsafe fn dc_get_location_kml(
@@ -331,14 +332,17 @@ pub unsafe fn dc_get_location_kml(
eos: 0 as *mut libc::c_char, eos: 0 as *mut libc::c_char,
}; };
dc_strbuilder_init(&mut ret, 1000i32); dc_strbuilder_init(&mut ret, 1000i32);
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
self_addr = dc_sqlite3_get_config( 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"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char, b"\x00" as *const u8 as *const libc::c_char,
); );
stmt = stmt =
dc_sqlite3_prepare((*context).sql, 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" b"SELECT locations_send_begin, locations_send_until, locations_last_sent FROM chats WHERE id=?;\x00"
as *const u8 as *const libc::c_char); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int); sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
@@ -354,7 +358,8 @@ pub unsafe fn dc_get_location_kml(
as *const u8 as *const libc::c_char, as *const u8 as *const libc::c_char,
self_addr); self_addr);
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, latitude, longitude, accuracy, timestamp\ b"SELECT id, latitude, longitude, accuracy, timestamp\
FROM locations WHERE from_id=? \ FROM locations WHERE from_id=? \
AND timestamp>=? \ AND timestamp>=? \
@@ -371,12 +376,9 @@ pub unsafe fn dc_get_location_kml(
sqlite3_bind_int(stmt, 4i32, 1i32); sqlite3_bind_int(stmt, 4i32, 1i32);
while sqlite3_step(stmt) == 100i32 { while sqlite3_step(stmt) == 100i32 {
let mut location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t; let mut location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let mut latitude: *mut libc::c_char = let mut latitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 1i32));
dc_ftoa(sqlite3_column_double(stmt, 1i32)); let mut longitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 2i32));
let mut longitude: *mut libc::c_char = let mut accuracy: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 3i32));
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 = let mut timestamp: *mut libc::c_char =
get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as time_t); get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as time_t);
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t, dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
@@ -402,7 +404,7 @@ pub unsafe fn dc_get_location_kml(
} }
} }
} }
}
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
free(self_addr as *mut libc::c_void); free(self_addr as *mut libc::c_void);
if 0 == success { 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( pub unsafe fn dc_get_message_kml(
context: &dc_context_t,
timestamp: time_t, timestamp: time_t,
latitude: libc::c_double, latitude: libc::c_double,
longitude: libc::c_double, longitude: libc::c_double,
) -> *mut libc::c_char { ) -> *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 timestamp_str = get_kml_timestamp(timestamp);
let latitude_str = dc_ftoa(latitude); let latitude_str = dc_ftoa(latitude);
let longitude_str = dc_ftoa(longitude); 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( pub unsafe fn dc_set_kml_sent_timestamp(
mut context: &dc_context_t, context: &dc_context_t,
mut chat_id: uint32_t, chat_id: uint32_t,
mut timestamp: time_t, timestamp: time_t,
) { ) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( 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 b"UPDATE chats SET locations_last_sent=? WHERE id=?;\x00" as *const u8
as *const libc::c_char, 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( 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, 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); 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 stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut newest_timestamp: time_t = 0i32 as time_t; let mut newest_timestamp: time_t = 0i32 as time_t;
let mut newest_location_id: uint32_t = 0i32 as uint32_t; let mut newest_location_id: uint32_t = 0i32 as uint32_t;
if !(context.is_null() if !(chat_id <= 9i32 as libc::c_uint || locations.is_null()) {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| chat_id <= 9i32 as libc::c_uint
|| locations.is_null())
{
stmt_test = dc_sqlite3_prepare( 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 b"SELECT id FROM locations WHERE timestamp=? AND from_id=?\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
stmt_insert = dc_sqlite3_prepare( stmt_insert = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO locations\ b"INSERT INTO locations\
(timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \ (timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
VALUES (?,?,?,?,?,?,?);\x00" as *const u8 as *const libc::c_char, 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 { if (*location).timestamp > newest_timestamp {
newest_timestamp = (*location).timestamp; newest_timestamp = (*location).timestamp;
newest_location_id = dc_sqlite3_get_rowid2( 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"locations\x00" as *const u8 as *const libc::c_char,
b"timestamp\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, (*location).timestamp as uint64_t,
@@ -591,7 +589,7 @@ pub unsafe fn dc_kml_parse(
text_cb: None, text_cb: None,
userdata: 0 as *mut libc::c_void, userdata: 0 as *mut libc::c_void,
}; };
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
if content_bytes > (1 * 1024 * 1024) { if content_bytes > (1 * 1024 * 1024) {
dc_log_warning( dc_log_warning(
context, context,
@@ -603,7 +601,7 @@ pub unsafe fn dc_kml_parse(
} else { } else {
content_nullterminated = dc_null_terminate(content, content_bytes as libc::c_int); content_nullterminated = dc_null_terminate(content, content_bytes as libc::c_int);
if !content_nullterminated.is_null() { if !content_nullterminated.is_null() {
(*kml).locations = dc_array_new_typed(context, 1, 100 as size_t); (*kml).locations = dc_array_new_typed(1, 100 as size_t);
dc_saxparser_init(&mut saxparser, kml as *mut libc::c_void); dc_saxparser_init(&mut saxparser, kml as *mut libc::c_void);
dc_saxparser_set_tag_handler( dc_saxparser_set_tag_handler(
&mut saxparser, &mut saxparser,
@@ -614,10 +612,11 @@ pub unsafe fn dc_kml_parse(
dc_saxparser_parse(&mut saxparser, content_nullterminated); dc_saxparser_parse(&mut saxparser, content_nullterminated);
} }
} }
}
free(content_nullterminated as *mut libc::c_void); free(content_nullterminated as *mut libc::c_void);
return kml; return kml;
} }
unsafe fn kml_text_cb(userdata: *mut libc::c_void, text: *const libc::c_char, _len: libc::c_int) { 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; let mut kml: *mut dc_kml_t = userdata as *mut dc_kml_t;
if 0 != (*kml).tag & (0x4 | 0x10) { 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, as *const libc::c_char,
); );
stmt_chats = dc_sqlite3_prepare( stmt_chats = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, locations_send_begin, locations_last_sent\ b"SELECT id, locations_send_begin, locations_last_sent\
FROM chats\ FROM chats\
WHERE locations_send_until>?;\x00" as *const u8 as *const libc::c_char, 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() { if stmt_locations.is_null() {
stmt_locations = dc_sqlite3_prepare( stmt_locations = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id \ b"SELECT id \
FROM locations \ FROM locations \
WHERE from_id=? \ 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 chat_id: uint32_t = (*job).foreign_id;
let mut locations_send_begin: time_t = 0i32 as time_t; let mut locations_send_begin: time_t = 0i32 as time_t;
let mut locations_send_until: 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; let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
stmt = dc_sqlite3_prepare( 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" b"SELECT locations_send_begin, locations_send_until FROM chats WHERE id=?\x00"
as *const u8 as *const libc::c_char, as *const u8 as *const libc::c_char,
); );
@@ -866,7 +868,9 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
{ {
// not streaming, device-message already sent // not streaming, device-message already sent
stmt = stmt =
dc_sqlite3_prepare((*context).sql, 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" b"UPDATE chats SET locations_send_begin=0, locations_send_until=0 WHERE id=?\x00"
as *const u8 as as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -880,7 +884,7 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
0i32 as uint32_t, 0i32 as uint32_t,
); );
dc_add_device_msg(context, chat_id, stock_str); dc_add_device_msg(context, chat_id, stock_str);
((*context).cb)( (context.cb)(
context, context,
Event::CHAT_MODIFIED, Event::CHAT_MODIFIED,
chat_id as uintptr_t, 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, mut va_0: ::std::ffi::VaList,
) { ) {
let mut msg: *mut libc::c_char = 0 as *mut libc::c_char; 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() { if !msg_format.is_null() {
let mut tempbuf: [libc::c_char; 1025] = [0; 1025]; let mut tempbuf: [libc::c_char; 1025] = [0; 1025];
vsnprintf( vsnprintf(
@@ -58,10 +55,7 @@ pub unsafe extern "C" fn dc_log_event_seq(
mut msg: *const libc::c_char, mut msg: *const libc::c_char,
mut va_0: ... mut va_0: ...
) { ) {
if context.is_null() if sequence_start.is_null() {
|| sequence_start.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
{
return; return;
} }
log_vprintf(context, event_code, *sequence_start, msg, va_0); log_vprintf(context, event_code, *sequence_start, msg, va_0);

55
src/dc_loginparam.rs
View File

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

54
src/dc_mimefactory.rs
View File

@@ -51,7 +51,7 @@ pub unsafe fn dc_mimefactory_init<'a>(
factory: *mut dc_mimefactory_t<'a>, factory: *mut dc_mimefactory_t<'a>,
context: &'a dc_context_t, context: &'a dc_context_t,
) { ) {
if factory.is_null() || context.is_null() { if factory.is_null() {
return; return;
} }
memset( memset(
@@ -105,16 +105,11 @@ pub unsafe fn dc_mimefactory_load_msg(
mut factory: *mut dc_mimefactory_t, mut factory: *mut dc_mimefactory_t,
mut msg_id: uint32_t, mut msg_id: uint32_t,
) -> libc::c_int { ) -> 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 success: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(factory.is_null() if !(factory.is_null() || msg_id <= 9i32 as libc::c_uint || !(*factory).msg.is_null()) {
|| msg_id <= 9i32 as libc::c_uint
|| (*factory).context.is_null()
|| !(*factory).msg.is_null())
{
/*call empty() before */ /*call empty() before */
context = (*factory).context; let context = (*factory).context;
(*factory).recipients_names = clist_new(); (*factory).recipients_names = clist_new();
(*factory).recipients_addr = clist_new(); (*factory).recipients_addr = clist_new();
(*factory).msg = dc_msg_new_untyped(context); (*factory).msg = dc_msg_new_untyped(context);
@@ -128,7 +123,7 @@ pub unsafe fn dc_mimefactory_load_msg(
clist_insert_after( clist_insert_after(
(*factory).recipients_names, (*factory).recipients_names,
(*(*factory).recipients_names).last, (*(*factory).recipients_names).last,
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( clist_insert_after(
(*factory).recipients_addr, (*factory).recipients_addr,
@@ -137,7 +132,9 @@ pub unsafe fn dc_mimefactory_load_msg(
); );
} else { } else {
stmt = stmt =
dc_sqlite3_prepare((*context).sql, 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" 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 as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -176,7 +173,8 @@ pub unsafe fn dc_mimefactory_load_msg(
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
let mut self_addr: *mut libc::c_char = dc_sqlite3_get_config( 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"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\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 if command != 6i32
&& command != 7i32 && command != 7i32
&& 0 != dc_sqlite3_get_config_int( && 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, b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32, 1i32,
) )
@@ -211,7 +210,8 @@ pub unsafe fn dc_mimefactory_load_msg(
} }
} }
stmt = dc_sqlite3_prepare( 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 b"SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?\x00" as *const u8
as *const libc::c_char, 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) { unsafe fn load_from(mut factory: *mut dc_mimefactory_t) {
(*factory).from_addr = dc_sqlite3_get_config( (*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, b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
(*factory).from_displayname = dc_sqlite3_get_config( (*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, b"displayname\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
(*factory).selfstatus = dc_sqlite3_get_config( (*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, b"selfstatus\x00" as *const u8 as *const libc::c_char,
0 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); (*factory).msg = dc_msg_new_untyped((*factory).context);
if !(0 if !(0
== dc_sqlite3_get_config_int( == 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, b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32, 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) if !(0 == dc_msg_load_from_db((*factory).msg, (*factory).context, msg_id)
|| 0 == dc_contact_load_from_db( || 0 == dc_contact_load_from_db(
contact, contact,
(*(*factory).context).sql, &mut (*factory).context.sql.clone().lock().unwrap(),
(*(*factory).msg).from_id, (*(*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, DC_PARAM_SET_LONGITUDE as libc::c_int,
0.0, 0.0,
); );
let kml_file = dc_get_message_kml( let kml_file =
(*msg).context, dc_get_message_kml((*msg).timestamp_sort, latitude, longitude);
(*msg).timestamp_sort,
latitude,
longitude,
);
if !kml_file.is_null() { if !kml_file.is_null() {
let content_type = mailmime_content_new_with_str( let content_type = mailmime_content_new_with_str(
b"application/vnd.google-earth.kml+xml\x00" as *const u8 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 msg: *const dc_msg_t,
mut afwd_email: libc::c_int, mut afwd_email: libc::c_int,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
let mut context: *mut dc_context_t = if !chat.is_null() { let context = (*chat).context;
(*chat).context
} else {
std::ptr::null_mut()
};
let mut ret: *mut libc::c_char = 0 as *mut libc::c_char; let mut ret: *mut libc::c_char = 0 as *mut libc::c_char;
let mut raw_subject: *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); 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)] #[derive(Copy, Clone)]
#[repr(C)] #[repr(C)]
pub struct dc_mimeparser_t { pub struct dc_mimeparser_t<'a> {
pub parts: *mut carray, pub parts: *mut carray,
pub mimeroot: *mut mailmime, pub mimeroot: *mut mailmime,
pub header: dc_hash_t, pub header: dc_hash_t,
@@ -47,7 +47,7 @@ pub struct dc_mimeparser_t {
pub e2ee_helper: *mut dc_e2ee_helper_t, pub e2ee_helper: *mut dc_e2ee_helper_t,
pub blobdir: *const libc::c_char, pub blobdir: *const libc::c_char,
pub is_forwarded: libc::c_int, pub is_forwarded: libc::c_int,
pub context: *mut dc_context_t, pub context: &'a dc_context_t,
pub reports: *mut carray, pub reports: *mut carray,
pub is_system_message: libc::c_int, pub is_system_message: libc::c_int,
pub location_kml: *mut dc_kml_t, 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. // deprecated: flag to switch generation of compound messages on and off.
static mut s_generate_compound_msgs: libc::c_int = 1i32; static mut s_generate_compound_msgs: libc::c_int = 1i32;
pub unsafe fn dc_mimeparser_new( pub unsafe fn dc_mimeparser_new(
mut blobdir: *const libc::c_char, blobdir: *const libc::c_char,
mut context: &dc_context_t, context: &dc_context_t,
) -> *mut dc_mimeparser_t { ) -> *mut dc_mimeparser_t {
let mut mimeparser: *mut dc_mimeparser_t = 0 as *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; 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 msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(dc_sqlite3_get_config_int( 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, b"mvbox_move\x00" as *const u8 as *const libc::c_char,
1i32, 1i32,
) == 0i32) ) == 0i32)

221
src/dc_msg.rs
View File

@@ -67,11 +67,16 @@ pub unsafe fn dc_get_msg_info(
eos: 0 as *mut libc::c_char, eos: 0 as *mut libc::c_char,
}; };
dc_strbuilder_init(&mut ret, 0i32); 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_msg_load_from_db(msg, context, msg_id);
dc_contact_load_from_db(contact_from, (*context).sql, (*msg).from_id); dc_contact_load_from_db(
contact_from,
&mut context.sql.clone().lock().unwrap(),
(*msg).from_id,
);
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT txt_raw FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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); sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
@@ -117,9 +122,10 @@ pub unsafe fn dc_get_msg_info(
if !((*msg).from_id == 2i32 as libc::c_uint || (*msg).to_id == 2i32 as libc::c_uint) { if !((*msg).from_id == 2i32 as libc::c_uint || (*msg).to_id == 2i32 as libc::c_uint) {
// device-internal message, no further details needed // device-internal message, no further details needed
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
(*context).sql, context,
b"SELECT contact_id, timestamp_sent FROM msgs_mdns WHERE msg_id=?;\x00" &mut context.sql.clone().lock().unwrap(),
as *const u8 as *const libc::c_char, 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); sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
while sqlite3_step(stmt) == 100i32 { while sqlite3_step(stmt) == 100i32 {
@@ -131,7 +137,7 @@ pub unsafe fn dc_get_msg_info(
let mut contact: *mut dc_contact_t = dc_contact_new(context); let mut contact: *mut dc_contact_t = dc_contact_new(context);
dc_contact_load_from_db( dc_contact_load_from_db(
contact, contact,
(*context).sql, &mut context.sql.clone().lock().unwrap(),
sqlite3_column_int64(stmt, 0i32) as uint32_t, sqlite3_column_int64(stmt, 0i32) as uint32_t,
); );
p = dc_contact_get_name_n_addr(contact); p = dc_contact_get_name_n_addr(contact);
@@ -152,9 +158,7 @@ pub unsafe fn dc_get_msg_info(
28 => p = dc_strdup(b"Read\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), 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), 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),
p = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, (*msg).state)
}
} }
dc_strbuilder_catf( dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t, &mut ret as *mut dc_strbuilder_t,
@@ -174,8 +178,7 @@ pub unsafe fn dc_get_msg_info(
if 0 != e2ee_errors { if 0 != e2ee_errors {
if 0 != e2ee_errors & 0x2i32 { if 0 != e2ee_errors & 0x2i32 {
p = dc_strdup( p = dc_strdup(
b"Encrypted, no valid signature\x00" as *const u8 b"Encrypted, no valid signature\x00" as *const u8 as *const libc::c_char,
as *const libc::c_char,
) )
} }
} else if 0 != dc_param_get_int((*msg).param, 'c' as i32, 0i32) { } else if 0 != dc_param_get_int((*msg).param, 'c' as i32, 0i32) {
@@ -219,10 +222,7 @@ pub unsafe fn dc_get_msg_info(
50 => p = dc_strdup(b"Video\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), 41 => p = dc_strdup(b"Voice\x00" as *const u8 as *const libc::c_char),
_ => { _ => {
p = dc_mprintf( p = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, (*msg).type_0)
b"%i\x00" as *const u8 as *const libc::c_char,
(*msg).type_0,
)
} }
} }
dc_strbuilder_catf( dc_strbuilder_catf(
@@ -264,8 +264,7 @@ pub unsafe fn dc_get_msg_info(
dc_strbuilder_cat(&mut ret, rawtxt); dc_strbuilder_cat(&mut ret, rawtxt);
dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char); dc_strbuilder_cat(&mut ret, b"\n\x00" as *const u8 as *const libc::c_char);
} }
if !(*msg).rfc724_mid.is_null() if !(*msg).rfc724_mid.is_null() && 0 != *(*msg).rfc724_mid.offset(0isize) as libc::c_int
&& 0 != *(*msg).rfc724_mid.offset(0isize) as libc::c_int
{ {
dc_strbuilder_catf( dc_strbuilder_catf(
&mut ret as *mut dc_strbuilder_t, &mut ret as *mut dc_strbuilder_t,
@@ -285,7 +284,7 @@ pub unsafe fn dc_get_msg_info(
} }
} }
} }
}
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
dc_msg_unref(msg); dc_msg_unref(msg);
dc_contact_unref(contact_from); dc_contact_unref(contact_from);
@@ -503,20 +502,18 @@ pub unsafe fn dc_msg_get_timestamp(mut msg: *const dc_msg_t) -> time_t {
(*msg).timestamp_sort (*msg).timestamp_sort
}; };
} }
pub unsafe fn dc_msg_load_from_db( pub unsafe fn dc_msg_load_from_db<'a>(
mut msg: *mut dc_msg_t, msg: *mut dc_msg_t<'a>,
mut context: &dc_context_t, context: &'a dc_context_t,
mut id: uint32_t, id: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt = 0 as *mut sqlite3_stmt;
if !(msg.is_null() if !msg.is_null() {
|| (*msg).magic != 0x11561156i32 as libc::c_uint
|| context.is_null()
|| (*context).sql.is_null())
{
stmt = stmt =
dc_sqlite3_prepare((*context).sql, 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, id as libc::c_int); sqlite3_bind_int(stmt, 1i32, id as libc::c_int);
@@ -612,18 +609,19 @@ pub unsafe fn dc_get_mime_headers(
mut context: &dc_context_t, mut context: &dc_context_t,
mut msg_id: uint32_t, mut msg_id: uint32_t,
) -> *mut libc::c_char { ) -> *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; 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( stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT mime_headers FROM msgs WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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); sqlite3_bind_int(stmt, 1i32, msg_id as libc::c_int);
if sqlite3_step(stmt) == 100i32 { if sqlite3_step(stmt) == 100i32 {
eml = dc_strdup_keep_null(sqlite3_column_text(stmt, 0i32) as *const libc::c_char) eml = dc_strdup_keep_null(sqlite3_column_text(stmt, 0i32) as *const libc::c_char)
} }
}
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
return eml; return eml;
} }
@@ -632,11 +630,7 @@ pub unsafe fn dc_delete_msgs(
mut msg_ids: *const uint32_t, mut msg_ids: *const uint32_t,
mut msg_cnt: libc::c_int, mut msg_cnt: libc::c_int,
) { ) {
if context.is_null() if msg_ids.is_null() || msg_cnt <= 0i32 {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_ids.is_null()
|| msg_cnt <= 0i32
{
return; return;
} }
let mut i: libc::c_int = 0i32; 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 msg_id: uint32_t,
mut chat_id: uint32_t, mut chat_id: uint32_t,
) { ) {
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare( let stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET chat_id=? WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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); 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_ids: *const uint32_t,
mut msg_cnt: libc::c_int, mut msg_cnt: libc::c_int,
) { ) {
let mut transaction_pending: libc::c_int = 0i32;
let mut i: libc::c_int = 0i32; let mut i: libc::c_int = 0i32;
let mut send_event: libc::c_int = 0i32; let mut send_event: libc::c_int = 0i32;
let mut curr_state: libc::c_int = 0i32; let mut curr_state: libc::c_int = 0i32;
let mut curr_blocked: libc::c_int = 0i32; let mut curr_blocked: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() if !(msg_ids.is_null() || msg_cnt <= 0i32) {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_ids.is_null()
|| msg_cnt <= 0i32)
{
transaction_pending = 1i32;
stmt = 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" 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); as *const u8 as *const libc::c_char);
i = 0i32; i = 0i32;
@@ -730,7 +719,7 @@ pub unsafe fn dc_markseen_msgs(
} }
i += 1 i += 1
} }
transaction_pending = 0i32;
if 0 != send_event { if 0 != send_event {
((*context).cb)( ((*context).cb)(
context, context,
@@ -747,7 +736,8 @@ pub unsafe fn dc_update_msg_state(
mut msg_id: uint32_t, mut msg_id: uint32_t,
mut state: libc::c_int, 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(), &mut context.sql.lock().unwrap(),
b"UPDATE msgs SET state=? WHERE id=?;\x00" as *const u8 as *const libc::c_char, 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 msg_cnt: libc::c_int,
mut star: libc::c_int, mut star: libc::c_int,
) { ) {
if context.is_null() if msg_ids.is_null() || msg_cnt <= 0i32 || star != 0i32 && star != 1i32 {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_ids.is_null()
|| msg_cnt <= 0i32
|| star != 0i32 && star != 1i32
{
return; return;
} }
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare( let mut stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET starred=? WHERE id=?;\x00" as *const u8 as *const libc::c_char, b"UPDATE msgs SET starred=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
); );
let mut i: libc::c_int = 0i32; 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 obj
} else { } else {
dc_msg_unref(obj); 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); 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 { 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; return 0i32;
} }
if dc_param_get_int((*msg).param, 'c' as i32, 0i32) != 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; return 0i32;
} }
pub unsafe fn dc_msg_get_summary( pub unsafe fn dc_msg_get_summary<'a>(
mut msg: *const dc_msg_t, msg: *const dc_msg_t<'a>,
mut chat: *const dc_chat_t, mut chat: *const dc_chat_t<'a>,
) -> *mut dc_lot_t { ) -> *mut dc_lot_t {
let mut current_block: u64; let mut current_block: u64;
let mut ret: *mut dc_lot_t = dc_lot_new(); 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 context: &dc_context_t,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
/* get a summary text, result must be free()'d, never returns NULL. */ /* 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 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 pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
let mut label: *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; return 0i32;
} }
pub unsafe fn dc_msg_is_increation(mut msg: *const dc_msg_t) -> libc::c_int { 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 0i32;
} }
return (((*msg).type_0 == 20i32 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) { pub unsafe fn dc_msg_save_param_to_disk(mut msg: *mut dc_msg_t) {
if msg.is_null() if msg.is_null() || (*msg).magic != 0x11561156i32 as libc::c_uint {
|| (*msg).magic != 0x11561156i32 as libc::c_uint
|| (*msg).context.is_null()
|| (*(*msg).context).sql.is_null()
{
return; return;
} }
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( 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, 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); 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, context: &'a dc_context_t,
msg_id: uint32_t, msg_id: uint32_t,
) -> *mut dc_msg_t<'a> { ) -> *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); dc_msg_load_from_db(msg, context, msg_id);
msg 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(0 == dc_msg_load_from_db(msg, context, msg_id)) { if !(0 == dc_msg_load_from_db(msg, context, msg_id)) {
stmt = dc_sqlite3_prepare( 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, 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_bind_int(stmt, 1i32, (*msg).id as libc::c_int);
sqlite3_step(stmt); sqlite3_step(stmt);
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
stmt = 0 as &sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( 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, 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); 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 { 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 msg_exists: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() if !msg_id <= 9i32 as libc::c_uint {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_id <= 9i32 as libc::c_uint)
{
stmt = dc_sqlite3_prepare( 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, 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); 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 // we update the move_state for all messages belonging to a given Message-ID
// so that the state stay intact when parts are deleted // so that the state stay intact when parts are deleted
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare( let mut stmt = dc_sqlite3_prepare(
(*context).sql, 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, 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); 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 msg_id: uint32_t,
mut error: *const libc::c_char, 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; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(0 == dc_msg_load_from_db(msg, context, msg_id)) { if !(0 == dc_msg_load_from_db(msg, context, msg_id)) {
if 18i32 == (*msg).state || 20i32 == (*msg).state || 26i32 == (*msg).state { 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( 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, b"UPDATE msgs SET state=?, param=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
); );
sqlite3_bind_int(stmt, 1i32, (*msg).state); sqlite3_bind_int(stmt, 1i32, (*msg).state);
@@ -1334,7 +1319,7 @@ pub unsafe fn dc_mdn_from_ext(
mut from_id: uint32_t, mut from_id: uint32_t,
mut rfc724_mid: *const libc::c_char, mut rfc724_mid: *const libc::c_char,
mut timestamp_sent: time_t, 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, mut ret_msg_id: *mut uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut chat_type: libc::c_int = 0; 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 soll_cnt: libc::c_int = 0;
let mut read_by_all: libc::c_int = 0i32; let mut read_by_all: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() if !(from_id <= 9i32 as libc::c_uint
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| from_id <= 9i32 as libc::c_uint
|| rfc724_mid.is_null() || rfc724_mid.is_null()
|| ret_chat_id.is_null() || ret_chat_id.is_null()
|| ret_msg_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) || *ret_msg_id != 0i32 as libc::c_uint)
{ {
stmt = stmt =
dc_sqlite3_prepare((*context).sql, 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" 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); as *const u8 as *const libc::c_char
);
sqlite3_bind_text(stmt, 1i32, rfc724_mid, -1i32, None); sqlite3_bind_text(stmt, 1i32, rfc724_mid, -1i32, None);
if !(sqlite3_step(stmt) != 100i32) { if !(sqlite3_step(stmt) != 100i32) {
*ret_msg_id = sqlite3_column_int(stmt, 0i32) as uint32_t; *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) { 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 */ /* 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( 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" b"SELECT contact_id FROM msgs_mdns WHERE msg_id=? AND contact_id=?;\x00"
as *const u8 as *const libc::c_char, as *const u8 as *const libc::c_char,
); );
@@ -1383,7 +1370,9 @@ pub unsafe fn dc_mdn_from_ext(
stmt = 0 as *mut sqlite3_stmt; stmt = 0 as *mut sqlite3_stmt;
if 0 == mdn_already_in_table { if 0 == mdn_already_in_table {
stmt = stmt =
dc_sqlite3_prepare((*context).sql, dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO msgs_mdns (msg_id, contact_id, timestamp_sent) VALUES (?, ?, ?);\x00" b"INSERT INTO msgs_mdns (msg_id, contact_id, timestamp_sent) VALUES (?, ?, ?);\x00"
as *const u8 as as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -1401,7 +1390,8 @@ pub unsafe fn dc_mdn_from_ext(
} else { } else {
/* send event about new state */ /* send event about new state */
stmt = dc_sqlite3_prepare( 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 b"SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=?;\x00" as *const u8
as *const libc::c_char, 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 { 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 stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut ret: size_t = 0i32 as size_t; 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 = 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 m.id>9 AND m.chat_id>9 AND c.blocked=0;\x00" 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); as *const u8 as *const libc::c_char);
if sqlite3_step(stmt) != 100i32 { if sqlite3_step(stmt) != 100i32 {
dc_sqlite3_log_error( 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, b"dc_get_real_msg_cnt() failed.\x00" as *const u8 as *const libc::c_char,
); );
} else { } 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 { 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 stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut ret: size_t = 0i32 as size_t; let mut ret: size_t = 0i32 as size_t;
if !(context.is_null() if !context.sql.clone().lock().unwrap().cobj.is_null() {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| (*(*context).sql).cobj.is_null())
{
stmt = 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" 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); as *const u8 as *const libc::c_char);
if !(sqlite3_step(stmt) != 100i32) { if !(sqlite3_step(stmt) != 100i32) {
@@ -1483,13 +1473,11 @@ pub unsafe fn dc_rfc724_mid_cnt(
) -> libc::c_int { ) -> libc::c_int {
/* check the number of messages with the same rfc724_mid */ /* check the number of messages with the same rfc724_mid */
let mut ret: libc::c_int = 0i32; let mut ret: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() if !context.sql.clone().lock().unwrap().cobj.is_null() {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| (*(*context).sql).cobj.is_null())
{
stmt = dc_sqlite3_prepare( 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 b"SELECT COUNT(*) FROM msgs WHERE rfc724_mid=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
@@ -1505,16 +1493,14 @@ pub unsafe fn dc_rfc724_mid_exists(
mut context: &dc_context_t, mut context: &dc_context_t,
mut rfc724_mid: *const libc::c_char, mut rfc724_mid: *const libc::c_char,
mut ret_server_folder: *mut *mut 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 { ) -> uint32_t {
let mut ret: uint32_t = 0i32 as uint32_t; let mut ret: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() if !(rfc724_mid.is_null() || *rfc724_mid.offset(0isize) as libc::c_int == 0i32) {
|| rfc724_mid.is_null()
|| *rfc724_mid.offset(0isize) as libc::c_int == 0i32)
{
stmt = dc_sqlite3_prepare( 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 b"SELECT server_folder, server_uid, id FROM msgs WHERE rfc724_mid=?;\x00" as *const u8
as *const libc::c_char, 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_folder: *const libc::c_char,
mut server_uid: uint32_t, mut server_uid: uint32_t,
) { ) {
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare( let mut stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET server_folder=?, server_uid=? WHERE rfc724_mid=?;\x00" as *const u8 b"UPDATE msgs SET server_folder=?, server_uid=? WHERE rfc724_mid=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );

73
src/dc_oauth2.rs
View File

@@ -28,15 +28,12 @@ pub unsafe fn dc_get_oauth2_url(
) -> *mut libc::c_char { ) -> *mut libc::c_char {
let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t; 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; let mut oauth2_url: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null() if !(redirect_uri.is_null() || *redirect_uri.offset(0isize) as libc::c_int == 0i32) {
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| redirect_uri.is_null()
|| *redirect_uri.offset(0isize) as libc::c_int == 0i32)
{
oauth2 = get_info(addr); oauth2 = get_info(addr);
if !oauth2.is_null() { if !oauth2.is_null() {
dc_sqlite3_set_config( 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, b"oauth2_pending_redirect_uri\x00" as *const u8 as *const libc::c_char,
redirect_uri, redirect_uri,
); );
@@ -154,12 +151,7 @@ pub unsafe fn dc_get_oauth2_access_token(
size: 0, size: 0,
}; 128]; }; 128];
let mut tok_cnt: libc::c_int = 0i32; let mut tok_cnt: libc::c_int = 0i32;
let mut locked: libc::c_int = 0i32; if code.is_null() || *code.offset(0isize) as 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
{
dc_log_warning( dc_log_warning(
context, context,
0i32, 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, b"Internal OAuth2 error: 2\x00" as *const u8 as *const libc::c_char,
); );
} else { } else {
pthread_mutex_lock(&mut (*context).oauth2_critical); let lock = context.oauth2_critical.clone();
locked = 1i32;
let l = lock.lock().unwrap();
// read generated token // read generated token
if 0 == flags & 0x1i32 && 0 == is_expired(context) { if 0 == flags & 0x1i32 && 0 == is_expired(context) {
access_token = dc_sqlite3_get_config( 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, b"oauth2_access_token\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
@@ -196,12 +190,14 @@ pub unsafe fn dc_get_oauth2_access_token(
16914036240511706173 => {} 16914036240511706173 => {}
_ => { _ => {
refresh_token = dc_sqlite3_get_config( 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, b"oauth2_refresh_token\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
refresh_token_for = dc_sqlite3_get_config( 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"oauth2_refresh_token_for\x00" as *const u8 as *const libc::c_char,
b"unset\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, as *const libc::c_char,
); );
redirect_uri = dc_sqlite3_get_config( 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"oauth2_pending_redirect_uri\x00" as *const u8 as *const libc::c_char,
b"unset\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, as *const libc::c_char,
); );
redirect_uri = dc_sqlite3_get_config( 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"oauth2_redirect_uri\x00" as *const u8 as *const libc::c_char,
b"unset\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, b"$REFRESH_TOKEN\x00" as *const u8 as *const libc::c_char,
refresh_token, refresh_token,
); );
json = ((*context).cb)( json = (context.cb)(
context, context,
Event::HTTP_POST, Event::HTTP_POST,
token_url as uintptr_t, 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 && 0 != *refresh_token.offset(0isize) as libc::c_int
{ {
dc_sqlite3_set_config( 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, b"oauth2_refresh_token\x00" as *const u8 as *const libc::c_char,
refresh_token, refresh_token,
); );
dc_sqlite3_set_config( dc_sqlite3_set_config(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_refresh_token_for\x00" as *const u8 b"oauth2_refresh_token_for\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
code, code,
@@ -405,12 +405,14 @@ pub unsafe fn dc_get_oauth2_access_token(
); );
} else { } else {
dc_sqlite3_set_config( 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, b"oauth2_access_token\x00" as *const u8 as *const libc::c_char,
access_token, access_token,
); );
dc_sqlite3_set_config_int64( dc_sqlite3_set_config_int64(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_timestamp_expires\x00" as *const u8 b"oauth2_timestamp_expires\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
(if 0 != expires_in { (if 0 != expires_in {
@@ -421,7 +423,8 @@ pub unsafe fn dc_get_oauth2_access_token(
); );
if 0 != update_redirect_uri_on_success { if 0 != update_redirect_uri_on_success {
dc_sqlite3_set_config( dc_sqlite3_set_config(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"oauth2_redirect_uri\x00" as *const u8 b"oauth2_redirect_uri\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
redirect_uri, 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 as *mut libc::c_void);
free(refresh_token_for as *mut libc::c_void); free(refresh_token_for as *mut libc::c_void);
free(redirect_uri 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 { unsafe fn is_expired(mut context: &dc_context_t) -> libc::c_int {
let mut expire_timestamp: time_t = dc_sqlite3_get_config_int64( 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, b"oauth2_timestamp_expires\x00" as *const u8 as *const libc::c_char,
0i32 as int64_t, 0i32 as int64_t,
) as time_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 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 addr_out: *mut libc::c_char = 0 as *mut libc::c_char;
let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t; let mut oauth2: *mut oauth2_t = 0 as *mut oauth2_t;
if !(context.is_null() if !({
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| {
oauth2 = get_info(addr); oauth2 = get_info(addr);
oauth2.is_null() oauth2.is_null()
} } || (*oauth2).get_userinfo.is_null())
|| (*oauth2).get_userinfo.is_null())
{ {
access_token = dc_get_oauth2_access_token(context, addr, code, 0i32); access_token = dc_get_oauth2_access_token(context, addr, code, 0i32);
addr_out = get_oauth2_addr(context, oauth2, access_token); addr_out = get_oauth2_addr(context, oauth2, access_token);
@@ -542,9 +541,7 @@ unsafe fn get_oauth2_addr(
size: 0, size: 0,
}; 128]; }; 128];
let mut tok_cnt: libc::c_int = 0i32; let mut tok_cnt: libc::c_int = 0i32;
if !(context.is_null() if !(access_token.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| access_token.is_null()
|| *access_token.offset(0isize) as libc::c_int == 0i32 || *access_token.offset(0isize) as libc::c_int == 0i32
|| oauth2.is_null()) || oauth2.is_null())
{ {
@@ -554,7 +551,7 @@ unsafe fn get_oauth2_addr(
b"$ACCESS_TOKEN\x00" as *const u8 as *const libc::c_char, b"$ACCESS_TOKEN\x00" as *const u8 as *const libc::c_char,
access_token, access_token,
); );
json = ((*context).cb)( json = (context.cb)(
context, context,
Event::HTTP_GET, Event::HTTP_GET,
userinfo_url as uintptr_t, 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. */ /* 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( pub unsafe fn dc_param_get(
mut param: *const dc_param_t, param: *const dc_param_t,
mut key: libc::c_int, key: libc::c_int,
mut def: *const libc::c_char, def: *const libc::c_char,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
let mut p1: *mut libc::c_char = 0 as *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; let mut p2: *mut libc::c_char = 0 as *mut libc::c_char;

30
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(); len = rpgp::rpgp_last_error_length();
if !(len == 0i32) { if !(len == 0i32) {
msg = rpgp::rpgp_last_error_message(); msg = rpgp::rpgp_last_error_message();
if !context.is_null() {
dc_log_info( dc_log_info(
context, context,
0i32, 0i32,
b"[rpgp][error] %s\x00" as *const u8 as *const libc::c_char, b"[rpgp][error] %s\x00" as *const u8 as *const libc::c_char,
msg, msg,
); );
}
success = 1i32 success = 1i32
} }
if !msg.is_null() { if !msg.is_null() {
@@ -218,11 +216,7 @@ pub unsafe fn dc_pgp_is_valid_key(
) -> libc::c_int { ) -> libc::c_int {
let mut key_is_valid: libc::c_int = 0i32; 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; let mut key: *mut rpgp::public_or_secret_key = 0 as *mut rpgp::public_or_secret_key;
if !(context.is_null() if !(raw_key.is_null() || (*raw_key).binary.is_null() || (*raw_key).bytes <= 0i32) {
|| raw_key.is_null()
|| (*raw_key).binary.is_null()
|| (*raw_key).bytes <= 0i32)
{
key = rpgp::rpgp_key_from_bytes( key = rpgp::rpgp_key_from_bytes(
(*raw_key).binary as *const uint8_t, (*raw_key).binary as *const uint8_t,
(*raw_key).bytes as usize, (*raw_key).bytes as usize,
@@ -242,9 +236,10 @@ pub unsafe fn dc_pgp_is_valid_key(
return key_is_valid; return key_is_valid;
} }
pub unsafe fn dc_pgp_calc_fingerprint( pub unsafe fn dc_pgp_calc_fingerprint(
mut raw_key: *const dc_key_t, context: &dc_context_t,
mut ret_fingerprint: *mut *mut uint8_t, raw_key: *const dc_key_t,
mut ret_fingerprint_bytes: *mut size_t, ret_fingerprint: *mut *mut uint8_t,
ret_fingerprint_bytes: *mut size_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut key: *mut rpgp::public_or_secret_key = 0 as *mut rpgp::public_or_secret_key; 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).binary as *const uint8_t,
(*raw_key).bytes as usize, (*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); 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_bytes = rpgp::rpgp_cvec_len(fingerprint) as size_t;
*ret_fingerprint = malloc(*ret_fingerprint_bytes) as *mut uint8_t; *ret_fingerprint = malloc(*ret_fingerprint_bytes) as *mut uint8_t;
memcpy( 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 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 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; 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 { if (*private_in).type_0 != 1i32 {
dc_log_warning( dc_log_warning(
context, 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 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 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; let mut encrypted: *mut rpgp::Message = 0 as *mut rpgp::Message;
if !(context.is_null() if !(plain_text == 0 as *mut libc::c_void
|| plain_text == 0 as *mut libc::c_void
|| plain_bytes == 0 || plain_bytes == 0
|| ret_ctext.is_null() || ret_ctext.is_null()
|| ret_ctext_bytes.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 = let mut private_keys: *mut *mut rpgp::signed_secret_key =
0 as *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; let mut public_keys: *mut *mut rpgp::signed_public_key = 0 as *mut *mut rpgp::signed_public_key;
if !(context.is_null() if !(ctext == 0 as *mut libc::c_void
|| ctext == 0 as *mut libc::c_void
|| ctext_bytes == 0 || ctext_bytes == 0
|| ret_plain.is_null() || ret_plain.is_null()
|| ret_plain_bytes.is_null() || ret_plain_bytes.is_null()
@@ -673,8 +666,7 @@ pub unsafe fn dc_pgp_symm_encrypt(
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut decrypted: *mut rpgp::Message = 0 as *mut rpgp::Message; let mut decrypted: *mut rpgp::Message = 0 as *mut rpgp::Message;
if !(context.is_null() if !(passphrase.is_null()
|| passphrase.is_null()
|| plain == 0 as *mut libc::c_void || plain == 0 as *mut libc::c_void
|| plain_bytes == 0 || plain_bytes == 0
|| ret_ctext_armored.is_null()) || 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 grpid: *mut libc::c_char = 0 as *mut libc::c_char;
let mut grpname: *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; (*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( dc_log_info(
context, context,
0i32, 0i32,
@@ -247,7 +247,7 @@ pub unsafe fn dc_check_qr(
if addr.is_null() || invitenumber.is_null() || auth.is_null() { if addr.is_null() || invitenumber.is_null() || auth.is_null() {
if 0 != dc_apeerstate_load_by_fingerprint( if 0 != dc_apeerstate_load_by_fingerprint(
peerstate, peerstate,
(*context).sql, &mut context.sql.clone().lock().unwrap(),
fingerprint, fingerprint,
) { ) {
(*qr_parsed).state = 210i32; (*qr_parsed).state = 210i32;

103
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 sent_timestamp: time_t = -1i32 as time_t;
let mut rcvd_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 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 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_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; 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, 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() if to_ids.is_null()
|| created_db_entries.is_null() || created_db_entries.is_null()
|| rr_event_to_send.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) sent_timestamp = dc_timestamp_from_date((*orig_date).dt_date_time)
} }
} }
transaction_pending = 1i32;
field = dc_mimeparser_lookup_field( field = dc_mimeparser_lookup_field(
mime_parser, mime_parser,
b"From\x00" as *const u8 as *const libc::c_char, 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; let mut fld_from: *mut mailimf_from = (*field).fld_data.fld_from;
if !fld_from.is_null() { if !fld_from.is_null() {
let mut check_self: libc::c_int = 0; 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( dc_add_or_lookup_contacts_by_mailbox_list(
context, context,
(*fld_from).frm_mb_list, (*fld_from).frm_mb_list,
@@ -225,7 +223,6 @@ pub unsafe fn dc_receive_imf(
if strcmp(old_server_folder, server_folder) != 0i32 if strcmp(old_server_folder, server_folder) != 0i32
|| old_server_uid != server_uid || old_server_uid != server_uid
{ {
transaction_pending = 0i32;
dc_update_server_uid( dc_update_server_uid(
context, context,
rfc724_mid, rfc724_mid,
@@ -253,7 +250,8 @@ pub unsafe fn dc_receive_imf(
let mut allow_creation: libc::c_int = 1i32; let mut allow_creation: libc::c_int = 1i32;
if msgrmsg == 0i32 { if msgrmsg == 0i32 {
let mut show_emails: libc::c_int = dc_sqlite3_get_config_int( 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, b"show_emails\x00" as *const u8 as *const libc::c_char,
0i32, 0i32,
); );
@@ -465,7 +463,8 @@ pub unsafe fn dc_receive_imf(
// if the mime-headers should be saved, find out its size // if the mime-headers should be saved, find out its size
// (the mime-header ends with an empty line) // (the mime-header ends with an empty line)
let mut save_mime_headers: libc::c_int = dc_sqlite3_get_config_int( 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, b"save_mime_headers\x00" as *const u8 as *const libc::c_char,
0i32, 0i32,
); );
@@ -529,7 +528,9 @@ pub unsafe fn dc_receive_imf(
} }
icnt = carray_count((*mime_parser).parts) as size_t; icnt = carray_count((*mime_parser).parts) as size_t;
stmt = stmt =
dc_sqlite3_prepare((*context).sql, 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" 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 as *const u8 as
*const libc::c_char); *const libc::c_char);
@@ -646,7 +647,8 @@ pub unsafe fn dc_receive_imf(
free(txt_raw as *mut libc::c_void); free(txt_raw as *mut libc::c_void);
txt_raw = 0 as *mut libc::c_char; txt_raw = 0 as *mut libc::c_char;
insert_msg_id = dc_sqlite3_get_rowid( 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"msgs\x00" as *const u8 as *const libc::c_char,
b"rfc724_mid\x00" as *const u8 as *const libc::c_char, b"rfc724_mid\x00" as *const u8 as *const libc::c_char,
rfc724_mid, rfc724_mid,
@@ -706,7 +708,8 @@ pub unsafe fn dc_receive_imf(
_ => { _ => {
if carray_count((*mime_parser).reports) > 0i32 as libc::c_uint { if carray_count((*mime_parser).reports) > 0i32 as libc::c_uint {
let mut mdns_enabled: libc::c_int = dc_sqlite3_get_config_int( 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, b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32, 1i32,
); );
@@ -897,7 +900,8 @@ pub unsafe fn dc_receive_imf(
dc_param_set_int(param, 'z' as i32, server_uid as int32_t); dc_param_set_int(param, 'z' as i32, server_uid as int32_t);
if 0 != (*mime_parser).is_send_by_messenger if 0 != (*mime_parser).is_send_by_messenger
&& 0 != dc_sqlite3_get_config_int( && 0 != dc_sqlite3_get_config_int(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_move\x00" as *const u8 b"mvbox_move\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
1i32, 1i32,
@@ -984,7 +988,6 @@ pub unsafe fn dc_receive_imf(
0i32, 0i32,
); );
} }
transaction_pending = 0i32
} }
} }
} }
@@ -1051,7 +1054,8 @@ unsafe fn calc_timestamps(
*sort_timestamp = message_timestamp; *sort_timestamp = message_timestamp;
if 0 != is_fresh_msg { if 0 != is_fresh_msg {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( 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" b"SELECT MAX(timestamp) FROM msgs WHERE chat_id=? and from_id!=? AND timestamp>=?\x00"
as *const u8 as *const libc::c_char, 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 */ /* check if the group does not exist but should be created */
group_explicitly_left = dc_is_group_explicitly_left(context, grpid); group_explicitly_left = dc_is_group_explicitly_left(context, grpid);
self_addr = dc_sqlite3_get_config( 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"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\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 && strlen(grpname) < 200
{ {
stmt = dc_sqlite3_prepare( stmt = dc_sqlite3_prepare(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET name=? WHERE id=?;\x00" as *const u8 b"UPDATE chats SET name=? WHERE id=?;\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
@@ -1460,7 +1466,8 @@ unsafe fn create_or_lookup_group(
0 as *mut libc::c_char 0 as *mut libc::c_char
}; };
stmt = dc_sqlite3_prepare( 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 b"DELETE FROM chats_contacts WHERE chat_id=?;\x00" as *const u8
as *const libc::c_char, 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" 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, as *const u8 as *const libc::c_char,
chat_ids_str); 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 { if sqlite3_step(stmt) == 100i32 {
chat_id = sqlite3_column_int(stmt, 0i32) as uint32_t; chat_id = sqlite3_column_int(stmt, 0i32) as uint32_t;
chat_id_blocked = sqlite3_column_int(stmt, 1i32); 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 chat_id: uint32_t = 0i32 as uint32_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare( 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 b"INSERT INTO chats (type, name, grpid, blocked) VALUES(?, ?, ?, ?);\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
@@ -1688,7 +1696,8 @@ unsafe fn create_group_record(
sqlite3_bind_int(stmt, 4i32, create_blocked); sqlite3_bind_int(stmt, 4i32, create_blocked);
if !(sqlite3_step(stmt) != 101i32) { if !(sqlite3_step(stmt) != 101i32) {
chat_id = dc_sqlite3_get_rowid( 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"chats\x00" as *const u8 as *const libc::c_char,
b"grpid\x00" as *const u8 as *const libc::c_char, b"grpid\x00" as *const u8 as *const libc::c_char,
grpid, grpid,
@@ -1707,7 +1716,7 @@ unsafe fn create_adhoc_grp_id(
- sha-256 this string (without possibly terminating null-characters) - sha-256 this string (without possibly terminating null-characters)
- encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f]) - encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f])
*/ */
let 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 = 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); 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; 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, as *const libc::c_char,
member_ids_str, 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( 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"configured_addr\x00" as *const u8 as *const libc::c_char,
b"no-self\x00" as *const u8 as *const libc::c_char, b"no-self\x00" as *const u8 as *const libc::c_char,
); );
@@ -1788,11 +1798,11 @@ unsafe fn search_chat_ids_by_contact_ids(
) -> *mut dc_array_t { ) -> *mut dc_array_t {
/* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */ /* searches chat_id's by the given contact IDs, may return zero, one or more chat_id's */
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; 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 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 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); let mut chat_ids: *mut dc_array_t = dc_array_new(23i32 as size_t);
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
/* copy array, remove duplicates and SELF, sort by ID */ /* copy array, remove duplicates and SELF, sort by ID */
let mut i: libc::c_int = 0; let mut i: libc::c_int = 0;
let mut iCnt: libc::c_int = dc_array_get_cnt(unsorted_contact_ids) as libc::c_int; let mut iCnt: libc::c_int = dc_array_get_cnt(unsorted_contact_ids) as libc::c_int;
@@ -1815,7 +1825,7 @@ unsafe fn search_chat_ids_by_contact_ids(
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" 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, as *const u8 as *const libc::c_char,
contact_ids_str); contact_ids_str);
stmt = dc_sqlite3_prepare((*context).sql, q3); stmt = dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(), q3);
let mut last_chat_id = 0; let mut last_chat_id = 0;
let mut matches = 0; let mut matches = 0;
let mut mismatches = 0; let mut mismatches = 0;
@@ -1843,7 +1853,7 @@ unsafe fn search_chat_ids_by_contact_ids(
} }
} }
} }
}
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
free(contact_ids_str as *mut libc::c_void); free(contact_ids_str as *mut libc::c_void);
dc_array_unref(contact_ids); 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 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 q3: *mut libc::c_char = 0 as *mut libc::c_char;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; 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( *failure_reason = dc_mprintf(
b"%s. See \"Info\" for details.\x00" as *const u8 as *const libc::c_char, 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, 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 // this check is skipped for SELF as there is no proper SELF-peerstate
// and results in group-splits otherwise. // and results in group-splits otherwise.
if from_id != 1i32 as libc::c_uint { if from_id != 1i32 as libc::c_uint {
if 0 == dc_apeerstate_load_by_addr(peerstate, (*context).sql, (*contact).addr) if 0 == dc_apeerstate_load_by_addr(
|| dc_contact_is_verified_ex(contact, peerstate) != 2i32 peerstate,
&mut context.sql.clone().lock().unwrap(),
(*contact).addr,
) || dc_contact_is_verified_ex(contact, peerstate) != 2i32
{ {
*failure_reason = dc_mprintf( *failure_reason = dc_mprintf(
b"%s. See \"Info\" for details.\x00" as *const u8 as *const libc::c_char, 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" 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, as *const u8 as *const libc::c_char,
to_ids_str); to_ids_str);
stmt = dc_sqlite3_prepare((*context).sql, q3); stmt = dc_sqlite3_prepare(context, &mut context.sql.clone().lock().unwrap(), q3);
loop { loop {
if !(sqlite3_step(stmt) == 100i32) { if !(sqlite3_step(stmt) == 100i32) {
current_block = 2604890879466389055; current_block = 2604890879466389055;
@@ -1935,7 +1948,11 @@ unsafe fn check_verified_properties(
strlen(to_addr) as libc::c_int, strlen(to_addr) as libc::c_int,
) )
.is_null() .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 if 0 == is_verified
|| strcmp( || strcmp(
@@ -1960,7 +1977,11 @@ unsafe fn check_verified_properties(
(*peerstate).gossip_key_fingerprint, (*peerstate).gossip_key_fingerprint,
2i32, 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 is_verified = 1i32
} }
} }
@@ -2095,7 +2116,7 @@ unsafe fn is_known_rfc724_mid(
let mut is_known: libc::c_int = 0i32; let mut is_known: libc::c_int = 0i32;
if !rfc724_mid.is_null() { if !rfc724_mid.is_null() {
let mut stmt: *mut sqlite3_stmt = 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" 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); as *const u8 as *const libc::c_char);
sqlite3_bind_text(stmt, 1i32, rfc724_mid, -1i32, None); 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; let mut is_msgrmsg: libc::c_int = 0i32;
if !rfc724_mid.is_null() { if !rfc724_mid.is_null() {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( 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" b"SELECT id FROM msgs WHERE rfc724_mid=? AND msgrmsg!=0 AND chat_id>9;\x00"
as *const u8 as *const libc::c_char, 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 ids: *mut dc_array_t,
mut check_self: *mut libc::c_int, 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; return;
} }
let mut cur: *mut clistiter = (*(*adr_list).ad_list).first; 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 ids: *mut dc_array_t,
mut check_self: *mut libc::c_int, 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; return;
} }
let mut cur: *mut clistiter = (*(*mb_list).mb_list).first; 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() { if check_self.is_null() {
check_self = &mut dummy 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; return;
} }
*check_self = 0i32; *check_self = 0i32;
let mut self_addr: *mut libc::c_char = dc_sqlite3_get_config( 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"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char, b"\x00" as *const u8 as *const libc::c_char,
); );

189
src/dc_securejoin.rs
View File

@@ -44,7 +44,7 @@ pub unsafe fn dc_get_securejoin_qr(
let mut chat: *mut dc_chat_t = 0 as *mut dc_chat_t; 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: *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; 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); dc_ensure_secret_key_exists(context);
invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id); invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id);
if invitenumber.is_null() { if invitenumber.is_null() {
@@ -57,7 +57,8 @@ pub unsafe fn dc_get_securejoin_qr(
dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, auth); dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, auth);
} }
self_addr = dc_sqlite3_get_config( 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"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
@@ -69,7 +70,8 @@ pub unsafe fn dc_get_securejoin_qr(
); );
} else { } else {
self_name = dc_sqlite3_get_config( self_name = dc_sqlite3_get_config(
(*context).sql, context,
&mut context.sql.clone().lock().unwrap(),
b"displayname\x00" as *const u8 as *const libc::c_char, b"displayname\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char, b"\x00" as *const u8 as *const libc::c_char,
); );
@@ -105,8 +107,7 @@ pub unsafe fn dc_get_securejoin_qr(
} }
} else { } else {
qr = dc_mprintf( qr = dc_mprintf(
b"OPENPGP4FPR:%s#a=%s&n=%s&i=%s&s=%s\x00" as *const u8 b"OPENPGP4FPR:%s#a=%s&n=%s&i=%s&s=%s\x00" as *const u8 as *const libc::c_char,
as *const libc::c_char,
fingerprint, fingerprint,
self_addr_urlencoded, self_addr_urlencoded,
self_name_urlencoded, self_name_urlencoded,
@@ -128,7 +129,7 @@ pub unsafe fn dc_get_securejoin_qr(
} }
} }
} }
}
free(self_addr_urlencoded as *mut libc::c_void); free(self_addr_urlencoded as *mut libc::c_void);
free(self_addr as *mut libc::c_void); free(self_addr as *mut libc::c_void);
free(self_name 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) dc_strdup(0 as *const libc::c_char)
}; };
} }
unsafe fn get_self_fingerprint(mut context: &dc_context_t) -> *mut 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_addr: *mut libc::c_char = 0 as *mut libc::c_char;
let mut self_key: *mut dc_key_t = dc_key_new(); let mut self_key: *mut dc_key_t = dc_key_new();
let mut fingerprint: *mut libc::c_char = 0 as *mut libc::c_char; let mut fingerprint: *mut libc::c_char = 0 as *mut libc::c_char;
self_addr = dc_sqlite3_get_config( 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"configured_addr\x00" as *const u8 as *const libc::c_char,
0 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)) { if !(self_addr.is_null()
fingerprint = dc_key_get_fingerprint(self_key); || 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(); fingerprint.is_null();
} }
free(self_addr as *mut libc::c_void); 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 contact_chat_id: uint32_t = 0i32 as uint32_t;
let mut join_vg: libc::c_int = 0i32; 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_scan: *mut dc_lot_t = 0 as *mut dc_lot_t;
let mut qr_locked: libc::c_int = 0i32;
dc_log_info( dc_log_info(
context, context,
0i32, 0i32,
@@ -199,16 +208,12 @@ pub unsafe fn dc_join_securejoin(
0i32, 0i32,
b"Unknown contact.\x00" as *const u8 as *const libc::c_char, 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; join_vg = ((*qr_scan).state == 202i32) as libc::c_int;
(*context).bobs_status = 0i32; let bob_a = context.bob.clone();
pthread_mutex_lock(&mut (*context).bobs_qr_critical); let mut bob = bob_a.write().unwrap();
qr_locked = 1i32; bob.status = 0;
(*context).bobs_qr_scan = qr_scan; bob.qr_scan = qr_scan;
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
}
if 0 != fingerprint_equals_sender(context, (*qr_scan).fingerprint, contact_chat_id) if 0 != fingerprint_equals_sender(context, (*qr_scan).fingerprint, contact_chat_id)
{ {
dc_log_info( dc_log_info(
@@ -216,8 +221,8 @@ pub unsafe fn dc_join_securejoin(
0i32, 0i32,
b"Taking protocol shortcut.\x00" as *const u8 as *const libc::c_char, b"Taking protocol shortcut.\x00" as *const u8 as *const libc::c_char,
); );
(*context).bob_expects = 6i32; bob.expects = 6;
((*context).cb)( (context.cb)(
context, context,
Event::SECUREJOIN_JOINER_PROGRESS, Event::SECUREJOIN_JOINER_PROGRESS,
chat_id_2_contact_id(context, contact_chat_id) as uintptr_t, 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); free(own_fingerprint as *mut libc::c_void);
} else { } else {
(*context).bob_expects = 2i32; bob.expects = 2;
send_handshake_msg( send_handshake_msg(
context, context,
contact_chat_id, contact_chat_id,
@@ -257,14 +262,17 @@ pub unsafe fn dc_join_securejoin(
); );
} }
// Bob -> Alice // Bob -> Alice
while !(0 != (*context).shall_stop_ongoing) { while !(0 != *context.shall_stop_ongoing.clone().read().unwrap()) {
usleep((300i32 * 1000i32) as useconds_t); usleep((300i32 * 1000i32) as useconds_t);
} }
} }
} }
} }
(*context).bob_expects = 0i32; let bob_a = context.bob.clone();
if (*context).bobs_status == 1i32 { let mut bob = bob_a.write().unwrap();
bob.expects = 0;
if bob.status == 1 {
if 0 != join_vg { if 0 != join_vg {
ret_chat_id = dc_get_chat_id_by_grpid( ret_chat_id = dc_get_chat_id_by_grpid(
context, context,
@@ -276,19 +284,15 @@ pub unsafe fn dc_join_securejoin(
ret_chat_id = contact_chat_id as libc::c_int ret_chat_id = contact_chat_id as libc::c_int
} }
} }
pthread_mutex_lock(&mut (*context).bobs_qr_critical); bob.qr_scan = std::ptr::null_mut();
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
}
dc_lot_unref(qr_scan); dc_lot_unref(qr_scan);
if 0 != ongoing_allocated { if 0 != ongoing_allocated {
dc_free_ongoing(context); dc_free_ongoing(context);
} }
return ret_chat_id as uint32_t; ret_chat_id as uint32_t
} }
unsafe fn send_handshake_msg( unsafe fn send_handshake_msg(
mut context: &dc_context_t, mut context: &dc_context_t,
mut contact_chat_id: uint32_t, mut contact_chat_id: uint32_t,
@@ -351,10 +355,14 @@ unsafe fn fingerprint_equals_sender(
if !(0 if !(0
== dc_contact_load_from_db( == dc_contact_load_from_db(
contact, contact,
(*context).sql, &mut context.sql.clone().lock().unwrap(),
dc_array_get_id(contacts, 0i32 as size_t), 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); fingerprint_normalized = dc_normalize_fingerprint(fingerprint);
if strcasecmp(fingerprint_normalized, (*peerstate).public_key_fingerprint) == 0i32 { if strcasecmp(fingerprint_normalized, (*peerstate).public_key_fingerprint) == 0i32 {
@@ -369,12 +377,11 @@ unsafe fn fingerprint_equals_sender(
} }
/* library private: secure-join */ /* library private: secure-join */
pub unsafe fn dc_handle_securejoin_handshake( pub unsafe fn dc_handle_securejoin_handshake(
mut context: &dc_context_t, context: &dc_context_t,
mut mimeparser: *mut dc_mimeparser_t, mimeparser: *mut dc_mimeparser_t,
mut contact_id: uint32_t, contact_id: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut current_block: u64; 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 step: *const libc::c_char = 0 as *const libc::c_char;
let mut join_vg: libc::c_int = 0i32; let mut join_vg: libc::c_int = 0i32;
let mut scanned_fingerprint_of_alice: *mut libc::c_char = 0 as *mut libc::c_char; 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 grpid: *mut libc::c_char = 0 as *mut libc::c_char;
let mut ret: libc::c_int = 0i32; let mut ret: libc::c_int = 0i32;
let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t; 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( step = lookup_field(
mimeparser, mimeparser,
b"Secure-Join\x00" as *const u8 as *const libc::c_char, b"Secure-Join\x00" as *const u8 as *const libc::c_char,
@@ -449,7 +456,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
0i32, 0i32,
b"Secure-join requested.\x00" as *const u8 as *const libc::c_char, b"Secure-join requested.\x00" as *const u8 as *const libc::c_char,
); );
((*context).cb)( (context.cb)(
context, context,
Event::SECUREJOIN_INVITER_PROGRESS, Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t, 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, b"vc-auth-required\x00" as *const u8 as *const libc::c_char,
) == 0i32 ) == 0i32
{ {
pthread_mutex_lock(&mut (*context).bobs_qr_critical); let bob_a = context.bob.clone();
qr_locked = 1i32; let bob = bob_a.read().unwrap();
if (*context).bobs_qr_scan.is_null() let scan = bob.qr_scan;
|| (*context).bob_expects != 2i32 if scan.is_null() || bob.expects != 2i32 || 0 != join_vg && (*scan).state != 202i32
|| 0 != join_vg && (*(*context).bobs_qr_scan).state != 202i32
{ {
dc_log_warning( dc_log_warning(
context, context,
@@ -493,15 +499,10 @@ pub unsafe fn dc_handle_securejoin_handshake(
// no error, just aborted somehow or a mail from another handshake // no error, just aborted somehow or a mail from another handshake
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
scanned_fingerprint_of_alice = scanned_fingerprint_of_alice = dc_strdup((*scan).fingerprint);
dc_strdup((*(*context).bobs_qr_scan).fingerprint); auth = dc_strdup((*scan).auth);
auth = dc_strdup((*(*context).bobs_qr_scan).auth);
if 0 != join_vg { if 0 != join_vg {
grpid = dc_strdup((*(*context).bobs_qr_scan).text2) grpid = dc_strdup((*scan).text2)
}
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
} }
if 0 == encrypted_and_signed(mimeparser, scanned_fingerprint_of_alice) { if 0 == encrypted_and_signed(mimeparser, scanned_fingerprint_of_alice) {
could_not_establish_secure_connection( 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, b"Fingerprint verified.\x00" as *const u8 as *const libc::c_char,
); );
own_fingerprint = get_self_fingerprint(context); own_fingerprint = get_self_fingerprint(context);
((*context).cb)( (context.cb)(
context, context,
Event::SECUREJOIN_JOINER_PROGRESS, Event::SECUREJOIN_JOINER_PROGRESS,
contact_id as uintptr_t, contact_id as uintptr_t,
400i32 as uintptr_t, 400i32 as uintptr_t,
); );
(*context).bob_expects = 6i32; context.bob.clone().write().unwrap().expects = 6;
send_handshake_msg( send_handshake_msg(
context, context,
contact_chat_id, 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, b"Auth verified.\x00" as *const u8 as *const libc::c_char,
); );
secure_connection_established(context, contact_chat_id); secure_connection_established(context, contact_chat_id);
((*context).cb)( (context.cb)(
context, context,
Event::CONTACTS_CHANGED, Event::CONTACTS_CHANGED,
contact_id as uintptr_t, contact_id as uintptr_t,
0i32 as uintptr_t, 0i32 as uintptr_t,
); );
((*context).cb)( (context.cb)(
context, context,
Event::SECUREJOIN_INVITER_PROGRESS, Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t, 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,
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
((*context).cb)( (context.cb)(
context, context,
Event::SECUREJOIN_INVITER_PROGRESS, Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t, contact_id as uintptr_t,
@@ -714,7 +716,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
if 0 != join_vg { if 0 != join_vg {
ret = 0x1i32 ret = 0x1i32
} }
if (*context).bob_expects != 6i32 { if context.bob.clone().read().unwrap().expects != 6 {
dc_log_info( dc_log_info(
context, context,
0i32, 0i32,
@@ -723,11 +725,8 @@ pub unsafe fn dc_handle_securejoin_handshake(
); );
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
pthread_mutex_lock(&mut (*context).bobs_qr_critical); let scan = context.bob.clone().read().unwrap().qr_scan;
qr_locked = 1i32; if scan.is_null() || 0 != join_vg && (*scan).state != 202i32 {
if (*context).bobs_qr_scan.is_null()
|| 0 != join_vg && (*(*context).bobs_qr_scan).state != 202i32
{
dc_log_warning( dc_log_warning(
context, context,
0i32, 0i32,
@@ -736,14 +735,9 @@ pub unsafe fn dc_handle_securejoin_handshake(
); );
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
scanned_fingerprint_of_alice = scanned_fingerprint_of_alice = dc_strdup((*scan).fingerprint);
dc_strdup((*(*context).bobs_qr_scan).fingerprint);
if 0 != join_vg { if 0 != join_vg {
grpid = dc_strdup((*(*context).bobs_qr_scan).text2) grpid = dc_strdup((*scan).text2)
}
if 0 != qr_locked {
pthread_mutex_unlock(&mut (*context).bobs_qr_critical);
qr_locked = 0i32
} }
let mut vg_expect_encrypted: libc::c_int = 1i32; let mut vg_expect_encrypted: libc::c_int = 1i32;
if 0 != join_vg { if 0 != join_vg {
@@ -788,7 +782,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
dc_scaleup_contact_origin(context, contact_id, 0x2000000i32); dc_scaleup_contact_origin(context, contact_id, 0x2000000i32);
((*context).cb)( (context.cb)(
context, context,
Event::CONTACTS_CHANGED, Event::CONTACTS_CHANGED,
0i32 as uintptr_t, 0i32 as uintptr_t,
@@ -818,7 +812,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
4378276786830486580 => {} 4378276786830486580 => {}
_ => { _ => {
secure_connection_established(context, contact_chat_id); secure_connection_established(context, contact_chat_id);
(*context).bob_expects = 0i32; context.bob.clone().write().unwrap().expects = 0;
if 0 != join_vg { if 0 != join_vg {
send_handshake_msg( send_handshake_msg(
context, context,
@@ -858,13 +852,13 @@ pub unsafe fn dc_handle_securejoin_handshake(
); );
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
((*context).cb)( (context.cb)(
context, context,
Event::SECUREJOIN_INVITER_PROGRESS, Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t, contact_id as uintptr_t,
800i32 as uintptr_t, 800i32 as uintptr_t,
); );
((*context).cb)( (context.cb)(
context, context,
Event::SECUREJOIN_INVITER_PROGRESS, Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t, 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); dc_contact_unref(contact);
free(scanned_fingerprint_of_alice as *mut libc::c_void); free(scanned_fingerprint_of_alice as *mut libc::c_void);
free(auth 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); free(grpid as *mut libc::c_void);
return ret; return ret;
} }
unsafe fn end_bobs_joining(mut context: &dc_context_t, mut status: libc::c_int) { unsafe fn end_bobs_joining(context: &dc_context_t, status: libc::c_int) {
(*context).bobs_status = status; context.bob.clone().write().unwrap().status = status;
dc_stop_ongoing_process(context); dc_stop_ongoing_process(context);
} }
unsafe fn secure_connection_established(mut context: &dc_context_t, mut contact_chat_id: uint32_t) { 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); dc_add_device_msg(context, contact_chat_id, msg);
((*context).cb)( (context.cb)(
context, context,
Event::CHAT_MODIFIED, Event::CHAT_MODIFIED,
contact_chat_id as uintptr_t, contact_chat_id as uintptr_t,
@@ -941,12 +931,12 @@ unsafe fn lookup_field(
return value; return value;
} }
unsafe fn could_not_establish_secure_connection( unsafe fn could_not_establish_secure_connection(
mut context: *mut dc_context_t, context: &dc_context_t,
mut contact_chat_id: uint32_t, contact_chat_id: uint32_t,
mut details: *const libc::c_char, details: *const libc::c_char,
) { ) {
let mut contact_id: uint32_t = chat_id_2_contact_id(context, contact_chat_id); 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( let mut msg: *mut libc::c_char = dc_stock_str_repl_string(
context, context,
36i32, 36i32,
@@ -968,16 +958,22 @@ unsafe fn could_not_establish_secure_connection(
dc_contact_unref(contact); dc_contact_unref(contact);
} }
unsafe fn mark_peer_as_verified( unsafe fn mark_peer_as_verified(
mut context: *mut dc_context_t, context: &dc_context_t,
mut fingerprint: *const libc::c_char, fingerprint: *const libc::c_char,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut peerstate: &dc_apeerstate_t = dc_apeerstate_new(context); let mut peerstate = dc_apeerstate_new(context);
if !(0 == dc_apeerstate_load_by_fingerprint(peerstate, (*context).sql, fingerprint)) { 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)) { if !(0 == dc_apeerstate_set_verified(peerstate, 1i32, fingerprint, 2i32)) {
(*peerstate).prefer_encrypt = 1i32; (*peerstate).prefer_encrypt = 1i32;
(*peerstate).to_save |= 0x2i32; (*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 success = 1i32
} }
} }
@@ -1037,10 +1033,10 @@ pub unsafe fn dc_handle_degrade_event(
mut context: &dc_context_t, mut context: &dc_context_t,
mut peerstate: *mut dc_apeerstate_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_id: uint32_t = 0i32 as uint32_t;
let mut contact_chat_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 // - 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 // - 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 // 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) // (and he will know this and can fix this)
if 0 != (*peerstate).degrade_event & 0x2i32 { if 0 != (*peerstate).degrade_event & 0x2i32 {
stmt = dc_sqlite3_prepare( 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, 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); 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_stock_str_repl_string(context, 37i32, (*peerstate).addr);
dc_add_device_msg(context, contact_chat_id, msg); dc_add_device_msg(context, contact_chat_id, msg);
free(msg as *mut libc::c_void); free(msg as *mut libc::c_void);
((*context).cb)( (context.cb)(
context, context,
Event::CHAT_MODIFIED, Event::CHAT_MODIFIED,
contact_chat_id as uintptr_t, 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 from: *mut libc::c_char,
pub esmtp: libc::c_int, pub esmtp: libc::c_int,
pub log_connect_errors: 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: *mut libc::c_char,
pub error_etpan: libc::c_int, pub error_etpan: libc::c_int,
} }
@@ -28,7 +26,6 @@ pub fn dc_smtp_new() -> dc_smtp_t {
from: std::ptr::null_mut(), from: std::ptr::null_mut(),
esmtp: 0, esmtp: 0,
log_connect_errors: 1, log_connect_errors: 1,
context: std::ptr::null_mut(),
error: std::ptr::null_mut(), error: std::ptr::null_mut(),
error_etpan: 0, error_etpan: 0,
} }
@@ -38,7 +35,6 @@ pub unsafe fn dc_smtp_unref(smtp: &mut dc_smtp_t) {
dc_smtp_disconnect(smtp); dc_smtp_disconnect(smtp);
free(smtp.from as *mut libc::c_void); free(smtp.from as *mut libc::c_void);
free(smtp.error 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) { 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 current_block: u64;
let mut success: libc::c_int = 0; let mut success: libc::c_int = 0;
let mut r: 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() { if !smtp.etpan.is_null() {
dc_log_warning( dc_log_warning(
smtp.context, context,
0, 0,
b"SMTP already connected.\x00" as *const u8 as *const libc::c_char, b"SMTP already connected.\x00" as *const u8 as *const libc::c_char,
); );
success = 1; success = 1;
} else if (*lp).addr.is_null() || (*lp).send_server.is_null() || (*lp).send_port == 0 { } else if (*lp).addr.is_null() || (*lp).send_server.is_null() || (*lp).send_port == 0 {
dc_log_event_seq( dc_log_event_seq(
smtp.context, context,
Event::ERROR_NETWORK, Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int, &mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP bad parameters.\x00" as *const u8 as *const libc::c_char, 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); smtp.etpan = mailsmtp_new(0 as size_t, None);
if smtp.etpan.is_null() { if smtp.etpan.is_null() {
dc_log_error( dc_log_error(
smtp.context, context,
0, 0,
b"SMTP-object creation failed.\x00" as *const u8 as *const libc::c_char, 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( mailsmtp_set_progress_callback(
smtp.etpan, smtp.etpan,
Some(body_progress), Some(body_progress),
smtp as *mut libc::c_void, smtp as *mut _ as *mut libc::c_void,
); );
/* connect to SMTP server */ /* connect to SMTP server */
if 0 != (*lp).server_flags & (0x10000 | 0x40000) { 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 { if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq( dc_log_event_seq(
smtp.context, context,
Event::ERROR_NETWORK, Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int, &mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-Socket connection to %s:%i failed (%s)\x00" as *const u8 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 { if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq( dc_log_event_seq(
smtp.context, context,
Event::ERROR_NETWORK, Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int, &mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-SSL connection to %s:%i failed (%s)\x00" as *const u8 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 { if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq( dc_log_event_seq(
smtp.context, context,
Event::ERROR_NETWORK, Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int, &mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-helo failed (%s)\x00" as *const u8 as *const libc::c_char, 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); r = mailsmtp_socket_starttls(smtp.etpan);
if r != MAILSMTP_NO_ERROR as libc::c_int { if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq( dc_log_event_seq(
smtp.context, context,
Event::ERROR_NETWORK, Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int, &mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-STARTTLS failed (%s)\x00" as *const u8 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 { if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq( dc_log_event_seq(
smtp.context, context,
Event::ERROR_NETWORK, Event::ERROR_NETWORK,
&mut smtp.log_connect_errors as *mut libc::c_int, &mut smtp.log_connect_errors as *mut libc::c_int,
b"SMTP-helo failed (%s)\x00" as *const u8 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; current_block = 12512295087047028901;
} else { } else {
dc_log_info( dc_log_info(
smtp.context, context,
0, 0,
b"SMTP-server %s:%i STARTTLS-connected.\x00" as *const u8 b"SMTP-server %s:%i STARTTLS-connected.\x00" as *const u8
as *const libc::c_char, 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 { } else {
if 0 != (*lp).server_flags & 0x40000 { if 0 != (*lp).server_flags & 0x40000 {
dc_log_info( dc_log_info(
smtp.context, context,
0, 0,
b"SMTP-server %s:%i connected.\x00" as *const u8 b"SMTP-server %s:%i connected.\x00" as *const u8
as *const libc::c_char, 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 { } else {
dc_log_info( dc_log_info(
smtp.context, context,
0, 0,
b"SMTP-server %s:%i SSL-connected.\x00" as *const u8 b"SMTP-server %s:%i SSL-connected.\x00" as *const u8
as *const libc::c_char, 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 !(*lp).send_user.is_null() {
if 0 != (*lp).server_flags & 0x2 { if 0 != (*lp).server_flags & 0x2 {
dc_log_info( dc_log_info(
smtp.context, context,
0, 0,
b"SMTP-OAuth2 connect...\x00" as *const u8 b"SMTP-OAuth2 connect...\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
); );
let mut access_token: *mut libc::c_char = let mut access_token: *mut libc::c_char =
dc_get_oauth2_access_token( dc_get_oauth2_access_token(
smtp.context, context,
(*lp).addr, (*lp).addr,
(*lp).send_pw, (*lp).send_pw,
0, 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 { if r != MAILSMTP_NO_ERROR as libc::c_int {
free(access_token as *mut libc::c_void); free(access_token as *mut libc::c_void);
access_token = dc_get_oauth2_access_token( access_token = dc_get_oauth2_access_token(
smtp.context, context,
(*lp).addr, (*lp).addr,
(*lp).send_pw, (*lp).send_pw,
0x1, 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 & MAILSMTP_AUTH_PLAIN as libc::c_int
{ {
dc_log_info( dc_log_info(
smtp.context, context,
0, 0,
b"Trying SMTP-Login workaround \"%s\"...\x00" b"Trying SMTP-Login workaround \"%s\"...\x00"
as *const u8 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 { if err < 0 {
dc_log_error( dc_log_error(
smtp.context, context,
0, 0,
b"SMTP-Login: Cannot get hostname.\x00" b"SMTP-Login: Cannot get hostname.\x00"
as *const u8 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 { if r != MAILSMTP_NO_ERROR as libc::c_int {
dc_log_event_seq( dc_log_event_seq(
smtp.context, context,
Event::ERROR_NETWORK, Event::ERROR_NETWORK,
&mut smtp.log_connect_errors &mut smtp.log_connect_errors
as *mut libc::c_int, 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; current_block = 12512295087047028901;
} else { } else {
dc_log_event( dc_log_event(
smtp.context, context,
Event::SMTP_CONNECTED, Event::SMTP_CONNECTED,
0, 0,
b"SMTP-login as %s ok.\x00" as *const u8 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( pub unsafe fn dc_smtp_send_msg(
context: &dc_context_t,
smtp: &mut dc_smtp_t, smtp: &mut dc_smtp_t,
recipients: *const clist, recipients: *const clist,
data_not_terminated: *const libc::c_char, 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 { if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error( log_error(
context,
smtp, smtp,
b"SMTP failed to start message\x00" as *const u8 as *const libc::c_char, b"SMTP failed to start message\x00" as *const u8 as *const libc::c_char,
r, r,
@@ -444,6 +446,7 @@ pub unsafe fn dc_smtp_send_msg(
}; };
if r != MAILSMTP_NO_ERROR as libc::c_int { if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error( log_error(
context,
smtp, smtp,
b"SMTP failed to add recipient\x00" as *const u8 as *const libc::c_char, b"SMTP failed to add recipient\x00" as *const u8 as *const libc::c_char,
r, r,
@@ -465,6 +468,7 @@ pub unsafe fn dc_smtp_send_msg(
r = mailsmtp_data(smtp.etpan); r = mailsmtp_data(smtp.etpan);
if r != MAILSMTP_NO_ERROR as libc::c_int { if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error( log_error(
context,
smtp, smtp,
b"SMTP failed to set data\x00" as *const u8 as *const libc::c_char, b"SMTP failed to set data\x00" as *const u8 as *const libc::c_char,
r, r,
@@ -473,6 +477,7 @@ pub unsafe fn dc_smtp_send_msg(
r = mailsmtp_data_message(smtp.etpan, data_not_terminated, data_bytes); r = mailsmtp_data_message(smtp.etpan, data_not_terminated, data_bytes);
if r != MAILSMTP_NO_ERROR as libc::c_int { if r != MAILSMTP_NO_ERROR as libc::c_int {
log_error( log_error(
context,
smtp, smtp,
b"SMTP failed to send message\x00" as *const u8 b"SMTP failed to send message\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
@@ -480,7 +485,7 @@ pub unsafe fn dc_smtp_send_msg(
); );
} else { } else {
dc_log_event( dc_log_event(
smtp.context, context,
Event::SMTP_MESSAGE_SENT, Event::SMTP_MESSAGE_SENT,
0, 0,
b"Message was sent to SMTP server\x00" as *const u8 b"Message was sent to SMTP server\x00" as *const u8
@@ -497,7 +502,12 @@ pub unsafe fn dc_smtp_send_msg(
success 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( let mut error_msg: *mut libc::c_char = dc_mprintf(
b"%s: %s: %s\x00" as *const u8 as *const libc::c_char, b"%s: %s: %s\x00" as *const u8 as *const libc::c_char,
what_failed, 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, (*smtp.etpan).response,
); );
dc_log_warning( dc_log_warning(
smtp.context, context,
0, 0,
b"%s\x00" as *const u8 as *const libc::c_char, b"%s\x00" as *const u8 as *const libc::c_char,
error_msg, error_msg,

186
src/dc_sqlite3.rs
View File

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

4
src/dc_stock.rs
View File

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

23
src/dc_token.rs
View File

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

56
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 { pub unsafe fn dc_smeared_time(mut context: &dc_context_t) -> time_t {
/* function returns a corrected time(NULL) */ /* function returns a corrected time(NULL) */
let mut now: time_t = time(0 as *mut time_t); let mut now: time_t = time(0 as *mut time_t);
pthread_mutex_lock(&mut (*context).smear_critical); let mut ts = *context.last_smeared_timestamp.clone().read().unwrap();
if (*context).last_smeared_timestamp >= now { if ts >= now {
now = (*context).last_smeared_timestamp + 1i32 as libc::c_long now = ts + 1;
} }
pthread_mutex_unlock(&mut (*context).smear_critical); now
return now;
} }
pub unsafe fn dc_create_smeared_timestamp(mut context: &dc_context_t) -> time_t { 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 now: time_t = time(0 as *mut time_t);
let mut ret: time_t = now; let mut ret: time_t = now;
pthread_mutex_lock(&mut (*context).smear_critical);
if ret <= (*context).last_smeared_timestamp { let mut ts = *context.last_smeared_timestamp.clone().write().unwrap();
ret = (*context).last_smeared_timestamp + 1i32 as libc::c_long; if ret <= ts {
if ret - now > 5i32 as libc::c_long { ret = ts + 1;
ret = now + 5i32 as libc::c_long if ret - now > 5 {
ret = now + 5
} }
} }
(*context).last_smeared_timestamp = ret; ts = ret;
pthread_mutex_unlock(&mut (*context).smear_critical); ret
return ret;
} }
pub unsafe fn dc_create_smeared_timestamps( pub unsafe fn dc_create_smeared_timestamps(
mut context: &dc_context_t, mut context: &dc_context_t,
mut count: libc::c_int, 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 now: time_t = time(0 as *mut time_t);
let mut start: time_t = let mut start: time_t =
now + (if count < 5i32 { count } else { 5i32 }) as libc::c_long - count as libc::c_long; 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 { let mut ts = *context.last_smeared_timestamp.clone().write().unwrap();
(*context).last_smeared_timestamp + 1i32 as libc::c_long start = if ts + 1 > start { ts + 1 } else { start };
} else { ts = start + ((count - 1) as time_t);
start start
};
(*context).last_smeared_timestamp = start + (count - 1i32) as libc::c_long;
pthread_mutex_unlock(&mut (*context).smear_critical);
return start;
} }
/* Message-ID tools */ /* Message-ID tools */
pub unsafe fn dc_create_id() -> *mut libc::c_char { 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: /* 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 current_block: u64;
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let mut pathNfilename_abs: *mut libc::c_char = 0 as *mut libc::c_char; 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); pathNfilename_abs = dc_strdup(pathNfilename);
if strncmp( if strncmp(
pathNfilename_abs, pathNfilename_abs,
@@ -1276,13 +1274,13 @@ pub unsafe fn dc_get_abs_path(
8, 8,
) == 0i32 ) == 0i32
{ {
if (*context).blobdir.is_null() { if context.blobdir.is_null() {
current_block = 3805228753452640762; current_block = 3805228753452640762;
} else { } else {
dc_str_replace( dc_str_replace(
&mut pathNfilename_abs, &mut pathNfilename_abs,
b"$BLOBDIR\x00" as *const u8 as *const libc::c_char, b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
(*context).blobdir, context.blobdir,
); );
current_block = 6937071982253665452; current_block = 6937071982253665452;
} }
@@ -1638,7 +1636,7 @@ pub unsafe fn dc_is_blobdir_path(
mut context: &dc_context_t, mut context: &dc_context_t,
mut path: *const libc::c_char, mut path: *const libc::c_char,
) -> libc::c_int { ) -> 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 || strncmp(path, b"$BLOBDIR\x00" as *const u8 as *const libc::c_char, 8) == 0i32
{ {
return 1i32; return 1i32;
@@ -1646,13 +1644,13 @@ pub unsafe fn dc_is_blobdir_path(
return 0i32; return 0i32;
} }
pub unsafe fn dc_make_rel_path(mut context: &dc_context_t, mut path: *mut *mut libc::c_char) { 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; return;
} }
if strncmp(*path, (*context).blobdir, strlen((*context).blobdir)) == 0i32 { if strncmp(*path, context.blobdir, strlen(context.blobdir)) == 0i32 {
dc_str_replace( dc_str_replace(
path, path,
(*context).blobdir, context.blobdir,
b"$BLOBDIR\x00" as *const u8 as *const libc::c_char, 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 success: libc::c_int = 0i32;
let mut filename: *mut libc::c_char = 0 as *mut libc::c_char; 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; 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) { if 0 != dc_is_blobdir_path(context, *path) {
dc_make_rel_path(context, path); dc_make_rel_path(context, path);
success = 1i32 success = 1i32