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

more rework

Browse Source
This commit is contained in:
dignifiedquire
2019-05-01 17:00:33 +02:00
parent 75319dbf67
commit 745a899530
5 changed files with 638 additions and 640 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/dc_context.rs
View File

@@ -36,11 +36,7 @@ pub struct dc_context_t {
pub sentbox_thread: dc_jobthread_t,
pub mvbox_thread: dc_jobthread_t,
pub smtp: Arc<Mutex<dc_smtp_t>>,
pub smtpidle: Arc<(Mutex<bool>, Condvar)>,
pub smtp_suspended: Arc<RwLock<i32>>,
pub smtp_doing_jobs: Arc<RwLock<i32>>,
pub perform_smtp_jobs_needed: Arc<RwLock<i32>>,
pub probe_smtp_network: Arc<RwLock<i32>>,
pub smtp_state: Arc<(Mutex<SmtpState>, Condvar)>,
pub oauth2_critical: Arc<Mutex<()>>,
pub cb: dc_callback_t,
pub os_name: *mut libc::c_char,
@@ -53,6 +49,15 @@ pub struct dc_context_t {
pub shall_stop_ongoing: i32,
}
#[derive(Default, Debug)]
pub struct SmtpState {
pub idle: bool,
pub suspended: i32,
pub doing_jobs: i32,
pub perform_jobs_needed: i32,
pub probe_network: i32,
}
// location handling
#[derive(Copy, Clone)]
#[repr(C)]
@@ -93,11 +98,7 @@ pub fn dc_context_new(
shall_stop_ongoing: 1,
sql: Arc::new(Mutex::new(dc_sqlite3_new())),
smtp: Arc::new(Mutex::new(dc_smtp_new())),
smtpidle: Arc::new((Mutex::new(false), Condvar::new())),
smtp_suspended: Arc::new(RwLock::new(0)),
smtp_doing_jobs: Arc::new(RwLock::new(0)),
perform_smtp_jobs_needed: Arc::new(RwLock::new(0)),
probe_smtp_network: Arc::new(RwLock::new(0)),
smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
oauth2_critical: Arc::new(Mutex::new(())),
bob_expects: 0,
bobs_status: 0,

622
src/dc_imex.rs
View File

@@ -50,10 +50,7 @@ pub unsafe fn dc_imex_has_backup(
let mut prefix_len = strlen(b"delta-chat\x00" as *const u8 as *const libc::c_char);
let mut suffix_len = strlen(b"bak\x00" as *const u8 as *const libc::c_char);
let mut curr_pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
let mut test_sql: *mut dc_sqlite3_t = 0 as *mut dc_sqlite3_t;
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return 0 as *mut libc::c_char;
}
let mut test_sql: Option<dc_sqlite3_t> = None;
dir_handle = opendir(dir_name);
if dir_handle.is_null() {
dc_log_info(
@@ -89,12 +86,14 @@ pub unsafe fn dc_imex_has_backup(
dir_name,
name,
);
dc_sqlite3_unref(test_sql);
test_sql = dc_sqlite3_new(context);
if !test_sql.is_null() && 0 != dc_sqlite3_open(test_sql, curr_pathNfilename, 0x1i32)
{
if test_sql.is_some() {
let mut test_sql = test_sql.take().unwrap();
dc_sqlite3_unref(context, &mut test_sql);
}
let mut sql = dc_sqlite3_new();
if 0 != dc_sqlite3_open(context, &mut sql, curr_pathNfilename, 0x1i32) {
let mut curr_backup_time: time_t = dc_sqlite3_get_config_int(
test_sql,
&mut sql,
b"backup_time\x00" as *const u8 as *const libc::c_char,
0i32,
) as time_t;
@@ -106,6 +105,7 @@ pub unsafe fn dc_imex_has_backup(
curr_pathNfilename = 0 as *mut libc::c_char
}
}
test_sql = Some(sql);
}
}
}
@@ -113,9 +113,12 @@ pub unsafe fn dc_imex_has_backup(
closedir(dir_handle);
}
free(curr_pathNfilename as *mut libc::c_void);
dc_sqlite3_unref(test_sql);
return ret;
if let Some(ref mut sql) = test_sql {
dc_sqlite3_unref(context, sql);
}
ret
}
pub unsafe fn dc_check_password(
mut context: &dc_context_t,
mut test_pw: *const libc::c_char,
@@ -125,23 +128,23 @@ pub unsafe fn dc_check_password(
When we start supporting OAuth some day, we should think this over, maybe force the user to re-authenticate himself with the Android password. */
let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new();
let mut success: libc::c_int = 0i32;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
dc_loginparam_read(
loginparam,
(*context).sql,
b"configured_\x00" as *const u8 as *const libc::c_char,
);
if ((*loginparam).mail_pw.is_null()
|| *(*loginparam).mail_pw.offset(0isize) as libc::c_int == 0i32)
&& (test_pw.is_null() || *test_pw.offset(0isize) as libc::c_int == 0i32)
{
success = 1i32
} else if (*loginparam).mail_pw.is_null() || test_pw.is_null() {
success = 0i32
} else if strcmp((*loginparam).mail_pw, test_pw) == 0i32 {
success = 1i32
}
dc_loginparam_read(
loginparam,
&mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char,
);
if ((*loginparam).mail_pw.is_null()
|| *(*loginparam).mail_pw.offset(0isize) as libc::c_int == 0i32)
&& (test_pw.is_null() || *test_pw.offset(0isize) as libc::c_int == 0i32)
{
success = 1i32
} else if (*loginparam).mail_pw.is_null() || test_pw.is_null() {
success = 0i32
} else if strcmp((*loginparam).mail_pw, test_pw) == 0i32 {
success = 1i32
}
dc_loginparam_unref(loginparam);
return success;
}
@@ -160,11 +163,11 @@ pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc:
setup_code = dc_create_setup_code(context);
if !setup_code.is_null() {
/* this may require a keypair to be created. this may take a second ... */
if !(0 != (*context).shall_stop_ongoing) {
if !(0 != context.shall_stop_ongoing) {
setup_file_content = dc_render_setup_file(context, setup_code);
if !setup_file_content.is_null() {
/* encrypting may also take a while ... */
if !(0 != (*context).shall_stop_ongoing) {
if !(0 != context.shall_stop_ongoing) {
setup_file_name = dc_get_fine_pathNfilename(
context,
b"$BLOBDIR\x00" as *const u8 as *const libc::c_char,
@@ -191,7 +194,7 @@ pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc:
);
dc_param_set_int((*msg).param, 'S' as i32, 6i32);
dc_param_set_int((*msg).param, 'u' as i32, 2i32);
if !(0 != (*context).shall_stop_ongoing) {
if !(0 != context.shall_stop_ongoing) {
msg_id = dc_send_msg(context, chat_id, msg);
if !(msg_id == 0i32 as libc::c_uint) {
dc_msg_unref(msg);
@@ -203,7 +206,7 @@ pub unsafe fn dc_initiate_key_transfer(mut context: &dc_context_t) -> *mut libc:
as *const libc::c_char,
);
loop {
if 0 != (*context).shall_stop_ongoing {
if 0 != context.shall_stop_ongoing {
current_block = 6116957410927263949;
break;
}
@@ -256,24 +259,23 @@ pub unsafe extern "C" fn dc_render_setup_file(
let mut passphrase_begin: [libc::c_char; 8] = [0; 8];
let mut encr_string: *mut libc::c_char = 0 as *mut libc::c_char;
let mut ret_setupfilecontent: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| passphrase.is_null()
|| strlen(passphrase) < 2
|| curr_private_key.is_null())
{
if !(passphrase.is_null() || strlen(passphrase) < 2 || curr_private_key.is_null()) {
strncpy(passphrase_begin.as_mut_ptr(), passphrase, 2);
passphrase_begin[2usize] = 0i32 as libc::c_char;
/* create the payload */
if !(0 == dc_ensure_secret_key_exists(context)) {
self_addr = dc_sqlite3_get_config(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
dc_key_load_self_private(curr_private_key, self_addr, (*context).sql);
dc_key_load_self_private(
curr_private_key,
self_addr,
&mut context.sql.clone().lock().unwrap(),
);
let mut e2ee_enabled: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
);
@@ -381,11 +383,7 @@ pub unsafe fn dc_continue_key_transfer(
let mut filebytes: size_t = 0i32 as size_t;
let mut armored_key: *mut libc::c_char = 0 as *mut libc::c_char;
let mut norm_sc: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| msg_id <= 9i32 as libc::c_uint
|| setup_code.is_null())
{
if !(msg_id <= 9i32 as libc::c_uint || setup_code.is_null()) {
msg = dc_get_msg(context, msg_id);
if msg.is_null()
|| 0 == dc_msg_is_setupmessage(msg)
@@ -494,7 +492,7 @@ unsafe fn set_self_key(
);
} else {
stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM keypairs WHERE public_key=? OR private_key=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -511,12 +509,12 @@ unsafe fn set_self_key(
stmt = 0 as *mut sqlite3_stmt;
if 0 != set_default {
dc_sqlite3_execute(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE keypairs SET is_default=0;\x00" as *const u8 as *const libc::c_char,
);
}
self_addr = dc_sqlite3_get_config(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
@@ -525,7 +523,7 @@ unsafe fn set_self_key(
private_key,
self_addr,
set_default,
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
) {
dc_log_error(
context,
@@ -540,7 +538,7 @@ unsafe fn set_self_key(
) == 0i32
{
dc_sqlite3_set_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
0i32,
);
@@ -550,7 +548,7 @@ unsafe fn set_self_key(
) == 0i32
{
dc_sqlite3_set_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
);
@@ -677,252 +675,247 @@ pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(mut context: &dc_context_t, mut job: *m
let mut what: libc::c_int = 0i32;
let mut param1: *mut libc::c_char = 0 as *mut libc::c_char;
let mut param2: *mut libc::c_char = 0 as *mut libc::c_char;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| (*context).sql.is_null())
{
if !(0 == dc_alloc_ongoing(context)) {
ongoing_allocated_here = 1i32;
what = dc_param_get_int((*job).param, 'S' as i32, 0i32);
param1 = dc_param_get((*job).param, 'E' as i32, 0 as *const libc::c_char);
param2 = dc_param_get((*job).param, 'F' as i32, 0 as *const libc::c_char);
if param1.is_null() {
if !(0 == dc_alloc_ongoing(context)) {
ongoing_allocated_here = 1i32;
what = dc_param_get_int((*job).param, 'S' as i32, 0i32);
param1 = dc_param_get((*job).param, 'E' as i32, 0 as *const libc::c_char);
param2 = dc_param_get((*job).param, 'F' as i32, 0 as *const libc::c_char);
if param1.is_null() {
dc_log_error(
context,
0i32,
b"No Import/export dir/file given.\x00" as *const u8 as *const libc::c_char,
);
} else {
dc_log_info(
context,
0i32,
b"Import/export process started.\x00" as *const u8 as *const libc::c_char,
);
(context.cb)(
context,
Event::IMEX_PROGRESS,
10i32 as uintptr_t,
0i32 as uintptr_t,
);
if 0 == dc_sqlite3_is_open(&mut context.sql.clone().lock().unwrap()) {
dc_log_error(
context,
0i32,
b"No Import/export dir/file given.\x00" as *const u8 as *const libc::c_char,
b"Import/export: Database not opened.\x00" as *const u8 as *const libc::c_char,
);
} else {
dc_log_info(
context,
0i32,
b"Import/export process started.\x00" as *const u8 as *const libc::c_char,
);
((*context).cb)(
context,
Event::IMEX_PROGRESS,
10i32 as uintptr_t,
0i32 as uintptr_t,
);
if 0 == dc_sqlite3_is_open((*context).sql) {
dc_log_error(
context,
0i32,
b"Import/export: Database not opened.\x00" as *const u8
as *const libc::c_char,
);
} else {
if what == 1i32 || what == 11i32 {
/* before we export anything, make sure the private key exists */
if 0 == dc_ensure_secret_key_exists(context) {
dc_log_error(context, 0i32,
if what == 1i32 || what == 11i32 {
/* before we export anything, make sure the private key exists */
if 0 == dc_ensure_secret_key_exists(context) {
dc_log_error(context, 0i32,
b"Import/export: Cannot create private key or private key not available.\x00"
as *const u8 as
*const libc::c_char);
current_block = 3568988166330621280;
} else {
dc_create_folder(context, param1);
current_block = 4495394744059808450;
}
current_block = 3568988166330621280;
} else {
dc_create_folder(context, param1);
current_block = 4495394744059808450;
}
match current_block {
3568988166330621280 => {}
_ => match what {
1 => {
current_block = 10991094515395304355;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
} else {
current_block = 4495394744059808450;
}
match current_block {
3568988166330621280 => {}
_ => match what {
1 => {
current_block = 10991094515395304355;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
}
2 => {
current_block = 11250025114629486028;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
}
}
}
2 => {
current_block = 11250025114629486028;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
}
11 => {
current_block = 12669919903773909120;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
}
}
}
11 => {
current_block = 12669919903773909120;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
}
12 => {
current_block = 2973387206439775448;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
}
}
}
12 => {
current_block = 2973387206439775448;
match current_block {
2973387206439775448 => {
if 0 == import_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
11250025114629486028 => {
if 0 == import_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
12669919903773909120 => {
if 0 == export_backup(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
_ => {
if 0 == export_self_keys(context, param1) {
current_block = 3568988166330621280;
} else {
current_block = 1118134448028020070;
}
}
}
_ => {}
},
}
match current_block {
3568988166330621280 => {}
_ => {
dc_log_info(
context,
0i32,
b"Import/export completed.\x00" as *const u8
as *const libc::c_char,
);
success = 1i32
}
}
}
_ => {}
},
}
}
}
}
free(param1 as *mut libc::c_void);
free(param2 as *mut libc::c_void);
if 0 != ongoing_allocated_here {
dc_free_ongoing(context);
}
((*context).cb)(
(context.cb)(
context,
Event::IMEX_PROGRESS,
(if 0 != success { 1000i32 } else { 0i32 }) as uintptr_t,
@@ -949,7 +942,7 @@ unsafe fn import_backup(
0i32,
b"Import \"%s\" to \"%s\".\x00" as *const u8 as *const libc::c_char,
backup_to_import,
(*context).dbfile,
context.dbfile,
);
if 0 != dc_is_configured(context) {
dc_log_error(
@@ -958,23 +951,30 @@ unsafe fn import_backup(
b"Cannot import backups to accounts in use.\x00" as *const u8 as *const libc::c_char,
);
} else {
if 0 != dc_sqlite3_is_open((*context).sql) {
dc_sqlite3_close((*context).sql);
if 0 != dc_sqlite3_is_open(&mut context.sql.clone().lock().unwrap()) {
dc_sqlite3_close(context, &mut context.sql.clone().lock().unwrap());
}
dc_delete_file(context, (*context).dbfile);
if 0 != dc_file_exist(context, (*context).dbfile) {
dc_delete_file(context, context.dbfile);
if 0 != dc_file_exist(context, context.dbfile) {
dc_log_error(
context,
0i32,
b"Cannot import backups: Cannot delete the old file.\x00" as *const u8
as *const libc::c_char,
);
} else if !(0 == dc_copy_file(context, backup_to_import, (*context).dbfile)) {
} else if !(0 == dc_copy_file(context, backup_to_import, context.dbfile)) {
/* error already logged */
/* re-open copied database file */
if !(0 == dc_sqlite3_open((*context).sql, (*context).dbfile, 0i32)) {
if !(0
== dc_sqlite3_open(
context,
&mut context.sql.clone().lock().unwrap(),
context.dbfile,
0i32,
))
{
stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"SELECT COUNT(*) FROM backup_blobs;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
@@ -982,7 +982,7 @@ unsafe fn import_backup(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"SELECT file_name, file_content FROM backup_blobs ORDER BY id;\x00"
as *const u8 as *const libc::c_char,
);
@@ -991,7 +991,7 @@ unsafe fn import_backup(
current_block = 10891380440665537214;
break;
}
if 0 != (*context).shall_stop_ongoing {
if 0 != context.shall_stop_ongoing {
current_block = 8648553629232744886;
break;
}
@@ -1003,7 +1003,7 @@ unsafe fn import_backup(
if permille > 990i32 {
permille = 990i32
}
((*context).cb)(
(context.cb)(
context,
Event::IMEX_PROGRESS,
permille as uintptr_t,
@@ -1019,7 +1019,7 @@ unsafe fn import_backup(
free(pathNfilename as *mut libc::c_void);
pathNfilename = dc_mprintf(
b"%s/%s\x00" as *const u8 as *const libc::c_char,
(*context).blobdir,
context.blobdir,
file_name,
);
if !(0
@@ -1050,11 +1050,12 @@ unsafe fn import_backup(
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
dc_sqlite3_execute(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"DROP TABLE backup_blobs;\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_try_execute(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"VACUUM;\x00" as *const u8 as *const libc::c_char,
);
success = 1i32
@@ -1079,7 +1080,6 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
let mut success: libc::c_int = 0i32;
let mut closed: libc::c_int = 0i32;
let mut dest_pathNfilename: *mut libc::c_char = 0 as *mut libc::c_char;
let mut dest_sql: *mut dc_sqlite3_t = 0 as *mut dc_sqlite3_t;
let mut now = time(0 as *mut time_t);
let mut dir_handle: *mut DIR = 0 as *mut DIR;
let mut dir_entry: *mut dirent = 0 as *mut dirent;
@@ -1092,6 +1092,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
let mut total_files_cnt: libc::c_int = 0i32;
let mut processed_files_cnt: libc::c_int = 0i32;
let mut delete_dest_file: libc::c_int = 0i32;
let mut dest_sql: Option<dc_sqlite3_t> = None;
/* get a fine backup file name (the name includes the date so that multiple backup instances are possible)
FIXME: we should write to a temporary file first and rename it on success. this would guarantee the backup is complete. however, currently it is not clear it the import exists in the long run (may be replaced by a restore-from-imap)*/
let mut timeinfo: *mut tm = 0 as *mut tm;
@@ -1113,33 +1114,40 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
} else {
dc_housekeeping(context);
dc_sqlite3_try_execute(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"VACUUM;\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_close((*context).sql);
dc_sqlite3_close(context, &mut context.sql.clone().lock().unwrap());
closed = 1i32;
dc_log_info(
context,
0i32,
b"Backup \"%s\" to \"%s\".\x00" as *const u8 as *const libc::c_char,
(*context).dbfile,
context.dbfile,
dest_pathNfilename,
);
if !(0 == dc_copy_file(context, (*context).dbfile, dest_pathNfilename)) {
if !(0 == dc_copy_file(context, context.dbfile, dest_pathNfilename)) {
/* error already logged */
dc_sqlite3_open((*context).sql, (*context).dbfile, 0i32);
dc_sqlite3_open(
context,
&mut context.sql.clone().lock().unwrap(),
context.dbfile,
0i32,
);
closed = 0i32;
/* add all files as blobs to the database copy (this does not require the source to be locked, neigher the destination as it is used only here) */
/*for logging only*/
dest_sql = dc_sqlite3_new(context);
if !(dest_sql.is_null() || 0 == dc_sqlite3_open(dest_sql, dest_pathNfilename, 0i32)) {
let mut sql = dc_sqlite3_new();
if 0 != dc_sqlite3_open(context, &mut sql, dest_pathNfilename, 0i32) {
/* error already logged */
if 0 == dc_sqlite3_table_exists(
dest_sql,
context,
&mut sql,
b"backup_blobs\x00" as *const u8 as *const libc::c_char,
) {
if 0 ==
dc_sqlite3_execute(dest_sql,
dc_sqlite3_execute(&mut sql,
b"CREATE TABLE backup_blobs (id INTEGER PRIMARY KEY, file_name, file_content);\x00"
as *const u8 as
*const libc::c_char) {
@@ -1153,7 +1161,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
11487273724841241105 => {}
_ => {
total_files_cnt = 0i32;
dir_handle = opendir((*context).blobdir);
dir_handle = opendir(context.blobdir);
if dir_handle.is_null() {
dc_log_error(
context,
@@ -1161,7 +1169,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
b"Backup: Cannot get info for blob-directory \"%s\".\x00"
as *const u8
as *const libc::c_char,
(*context).blobdir,
context.blobdir,
);
} else {
loop {
@@ -1175,7 +1183,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
dir_handle = 0 as *mut DIR;
if total_files_cnt > 0i32 {
/* scan directory, pass 2: copy files */
dir_handle = opendir((*context).blobdir);
dir_handle = opendir(context.blobdir);
if dir_handle.is_null() {
dc_log_error(
context,
@@ -1183,12 +1191,12 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
b"Backup: Cannot copy from blob-directory \"%s\".\x00"
as *const u8
as *const libc::c_char,
(*context).blobdir,
context.blobdir,
);
current_block = 11487273724841241105;
} else {
stmt =
dc_sqlite3_prepare(dest_sql,
dc_sqlite3_prepare(&mut sql,
b"INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);\x00"
as *const u8 as
*const libc::c_char);
@@ -1198,7 +1206,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
current_block = 2631791190359682872;
break;
}
if 0 != (*context).shall_stop_ongoing {
if 0 != context.shall_stop_ongoing {
delete_dest_file = 1i32;
current_block = 11487273724841241105;
break;
@@ -1212,7 +1220,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
if permille > 990i32 {
permille = 990i32
}
((*context).cb)(
(context.cb)(
context,
Event::IMEX_PROGRESS,
permille as uintptr_t,
@@ -1252,7 +1260,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
curr_pathNfilename = dc_mprintf(
b"%s/%s\x00" as *const u8
as *const libc::c_char,
(*context).blobdir,
context.blobdir,
name,
);
free(buf);
@@ -1299,7 +1307,7 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
0i32,
b"Backup: No files to copy.\x00" as *const u8
as *const libc::c_char,
(*context).blobdir,
context.blobdir,
);
current_block = 2631791190359682872;
}
@@ -1307,11 +1315,11 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
11487273724841241105 => {}
_ => {
dc_sqlite3_set_config_int(
dest_sql,
&mut sql,
b"backup_time\x00" as *const u8 as *const libc::c_char,
now as int32_t,
);
((*context).cb)(
(context.cb)(
context,
Event::IMEX_FILE_WRITTEN,
dest_pathNfilename as uintptr_t,
@@ -1324,17 +1332,25 @@ unsafe fn export_backup(mut context: &dc_context_t, mut dir: *const libc::c_char
}
}
}
dest_sql = Some(sql);
}
}
if !dir_handle.is_null() {
closedir(dir_handle);
}
if 0 != closed {
dc_sqlite3_open((*context).sql, (*context).dbfile, 0i32);
dc_sqlite3_open(
context,
&mut context.sql.clone().lock().unwrap(),
context.dbfile,
0i32,
);
}
sqlite3_finalize(stmt);
dc_sqlite3_close(dest_sql);
dc_sqlite3_unref(dest_sql);
if let Some(ref mut sql) = dest_sql {
dc_sqlite3_close(context, sql);
dc_sqlite3_unref(context, sql);
}
if 0 != delete_dest_file {
dc_delete_file(context, dest_pathNfilename);
}
@@ -1357,7 +1373,7 @@ unsafe fn import_self_keys(
Maybe we should make the "default" key handlong also a little bit smarter
(currently, the last imported key is the standard key unless it contains the string "legacy" in its name) */
let mut imported_cnt: libc::c_int = 0i32;
let mut dir_handle: &DIR = 0 as *mut DIR;
let mut dir_handle = 0 as *mut DIR;
let mut dir_entry: *mut dirent = 0 as *mut dirent;
let mut suffix: *mut libc::c_char = 0 as *mut libc::c_char;
let mut path_plus_name: *mut libc::c_char = 0 as *mut libc::c_char;
@@ -1369,10 +1385,7 @@ unsafe fn import_self_keys(
let mut buf2: *mut libc::c_char = 0 as *mut libc::c_char;
// a pointer inside buf2, MUST NOT be free()'d
let mut buf2_headerline: *const libc::c_char = 0 as *const libc::c_char;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| dir_name.is_null())
{
if !dir_name.is_null() {
dir_handle = opendir(dir_name);
if dir_handle.is_null() {
dc_log_error(
@@ -1486,13 +1499,12 @@ unsafe fn export_self_keys(
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut export_errors: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut id: libc::c_int = 0i32;
let mut is_default: libc::c_int = 0i32;
let mut public_key: *mut dc_key_t = dc_key_new();
let mut private_key: *mut dc_key_t = dc_key_new();
stmt = dc_sqlite3_prepare(
(*context).sql,
let stmt = dc_sqlite3_prepare(
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, public_key, private_key, is_default FROM keypairs;\x00" as *const u8
as *const libc::c_char,
);
@@ -1529,7 +1541,7 @@ unsafe fn export_key_to_asc_file(
mut is_default: libc::c_int,
) -> libc::c_int {
let mut success: libc::c_int = 0i32;
let mut file_name: &libc::c_char = 0 as *mut libc::c_char;
let mut file_name = 0 as *mut libc::c_char;
if 0 != is_default {
file_name = dc_mprintf(
b"%s/%s-key-default.asc\x00" as *const u8 as *const libc::c_char,
@@ -1567,7 +1579,7 @@ unsafe fn export_key_to_asc_file(
file_name,
);
} else {
((*context).cb)(
(context.cb)(
context,
Event::IMEX_FILE_WRITTEN,
file_name as uintptr_t,

629
src/dc_job.rs
View File

@@ -1,5 +1,6 @@
use libc;
use rand::{thread_rng, Rng};
use std::time::Duration;
use crate::constants::Event;
use crate::dc_chat::*;
@@ -45,20 +46,18 @@ pub struct dc_job_t {
pub pending_error: *mut libc::c_char,
}
pub unsafe fn dc_perform_imap_jobs(mut context: &dc_context_t) {
pub unsafe fn dc_perform_imap_jobs(context: &dc_context_t) {
dc_log_info(
context,
0i32,
b"INBOX-jobs started...\x00" as *const u8 as *const libc::c_char,
);
let l = (*context).inboxidle_condmutex.lock().unwrap();
let mut probe_imap_network: libc::c_int = (*context).probe_imap_network;
(*context).probe_imap_network = 0i32;
(*context).perform_inbox_jobs_needed = 0i32;
drop(l);
let probe_imap_network = *context.probe_imap_network.clone().read().unwrap();
*context.probe_imap_network.clone().write().unwrap() = 0;
*context.perform_inbox_jobs_needed.clone().write().unwrap() = 0;
dc_job_perform(context, 100i32, probe_imap_network);
dc_job_perform(context, 100, probe_imap_network);
dc_log_info(
context,
0i32,
@@ -88,122 +87,122 @@ unsafe fn dc_job_perform(
::std::mem::size_of::<dc_job_t>(),
);
job.param = dc_param_new();
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
if probe_network == 0i32 {
select_stmt =
dc_sqlite3_prepare((*context).sql,
if probe_network == 0i32 {
select_stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
b"SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries FROM jobs WHERE thread=? AND desired_timestamp<=? ORDER BY action DESC, added_timestamp;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64);
sqlite3_bind_int64(select_stmt, 2i32, time(0 as *mut time_t) as sqlite3_int64);
} else {
select_stmt =
dc_sqlite3_prepare((*context).sql,
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64);
sqlite3_bind_int64(select_stmt, 2i32, time(0 as *mut time_t) as sqlite3_int64);
} else {
select_stmt =
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
b"SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries FROM jobs WHERE thread=? AND tries>0 ORDER BY desired_timestamp, action DESC;\x00"
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);
}
while sqlite3_step(select_stmt) == 100i32 {
job.job_id = sqlite3_column_int(select_stmt, 0i32) as uint32_t;
job.action = sqlite3_column_int(select_stmt, 1i32);
job.foreign_id = sqlite3_column_int(select_stmt, 2i32) as uint32_t;
dc_param_set_packed(
job.param,
sqlite3_column_text(select_stmt, 3i32) as *mut libc::c_char,
);
job.added_timestamp = sqlite3_column_int64(select_stmt, 4i32) as time_t;
job.desired_timestamp = sqlite3_column_int64(select_stmt, 5i32) as time_t;
job.tries = sqlite3_column_int(select_stmt, 6i32);
dc_log_info(
context,
0i32,
b"%s-job #%i, action %i started...\x00" as *const u8 as *const libc::c_char,
if thread == 100i32 {
b"INBOX\x00" as *const u8 as *const libc::c_char
} else {
b"SMTP\x00" as *const u8 as *const libc::c_char
},
job.job_id as libc::c_int,
job.action as libc::c_int,
);
if 900i32 == job.action || 910i32 == job.action {
dc_job_kill_action(context, job.action);
sqlite3_finalize(select_stmt);
select_stmt = 0 as *mut sqlite3_stmt;
dc_jobthread_suspend(&mut context.sentbox_thread, 1i32);
dc_jobthread_suspend(&mut context.mvbox_thread, 1i32);
dc_suspend_smtp_thread(context, 1i32);
}
while sqlite3_step(select_stmt) == 100i32 {
job.job_id = sqlite3_column_int(select_stmt, 0i32) as uint32_t;
job.action = sqlite3_column_int(select_stmt, 1i32);
job.foreign_id = sqlite3_column_int(select_stmt, 2i32) as uint32_t;
dc_param_set_packed(
job.param,
sqlite3_column_text(select_stmt, 3i32) as *mut libc::c_char,
);
job.added_timestamp = sqlite3_column_int64(select_stmt, 4i32) as time_t;
job.desired_timestamp = sqlite3_column_int64(select_stmt, 5i32) as time_t;
job.tries = sqlite3_column_int(select_stmt, 6i32);
let mut tries: libc::c_int = 0i32;
while tries <= 1i32 {
job.try_again = 0i32;
match job.action {
5901 => {
dc_job_do_DC_JOB_SEND(context, &mut job);
}
110 => {
dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context, &mut job);
}
130 => {
dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context, &mut job);
}
120 => {
dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context, &mut job);
}
200 => {
dc_job_do_DC_JOB_MOVE_MSG(context, &mut job);
}
5011 => {
dc_job_do_DC_JOB_SEND(context, &mut job);
}
900 => {
dc_job_do_DC_JOB_CONFIGURE_IMAP(context, &mut job);
}
910 => {
dc_job_do_DC_JOB_IMEX_IMAP(context, &mut job);
}
5005 => {
dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context, &mut job);
}
5007 => {
dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context, &mut job);
}
105 => {
dc_housekeeping(context);
}
_ => {}
}
if job.try_again != -1i32 {
break;
}
tries += 1
}
if 900i32 == job.action || 910i32 == job.action {
dc_jobthread_suspend(&mut context.sentbox_thread, 0i32);
dc_jobthread_suspend(&mut context.mvbox_thread, 0i32);
dc_suspend_smtp_thread(context, 0i32);
break;
} else if job.try_again == 2i32 {
dc_log_info(
context,
0i32,
b"%s-job #%i, action %i started...\x00" as *const u8 as *const libc::c_char,
b"%s-job #%i not yet ready and will be delayed.\x00" as *const u8
as *const libc::c_char,
if thread == 100i32 {
b"INBOX\x00" as *const u8 as *const libc::c_char
} else {
b"SMTP\x00" as *const u8 as *const libc::c_char
},
job.job_id as libc::c_int,
job.action as libc::c_int,
);
if 900i32 == job.action || 910i32 == job.action {
dc_job_kill_action(context, job.action);
sqlite3_finalize(select_stmt);
select_stmt = 0 as *mut sqlite3_stmt;
dc_jobthread_suspend(&mut (*context).sentbox_thread, 1i32);
dc_jobthread_suspend(&mut (*context).mvbox_thread, 1i32);
dc_suspend_smtp_thread(context, 1i32);
}
let mut tries: libc::c_int = 0i32;
while tries <= 1i32 {
job.try_again = 0i32;
match job.action {
5901 => {
dc_job_do_DC_JOB_SEND(context, &mut job);
}
110 => {
dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context, &mut job);
}
130 => {
dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context, &mut job);
}
120 => {
dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context, &mut job);
}
200 => {
dc_job_do_DC_JOB_MOVE_MSG(context, &mut job);
}
5011 => {
dc_job_do_DC_JOB_SEND(context, &mut job);
}
900 => {
dc_job_do_DC_JOB_CONFIGURE_IMAP(context, &mut job);
}
910 => {
dc_job_do_DC_JOB_IMEX_IMAP(context, &mut job);
}
5005 => {
dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context, &mut job);
}
5007 => {
dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context, &mut job);
}
105 => {
dc_housekeeping(context);
}
_ => {}
}
if job.try_again != -1i32 {
break;
}
tries += 1
}
if 900i32 == job.action || 910i32 == job.action {
dc_jobthread_suspend(&mut (*context).sentbox_thread, 0i32);
dc_jobthread_suspend(&mut (*context).mvbox_thread, 0i32);
dc_suspend_smtp_thread(context, 0i32);
break;
} else if job.try_again == 2i32 {
dc_log_info(
context,
0i32,
b"%s-job #%i not yet ready and will be delayed.\x00" as *const u8
as *const libc::c_char,
if thread == 100i32 {
b"INBOX\x00" as *const u8 as *const libc::c_char
} else {
b"SMTP\x00" as *const u8 as *const libc::c_char
},
job.job_id as libc::c_int,
);
} else if job.try_again == -1i32 || job.try_again == 3i32 {
let mut tries_0: libc::c_int = job.tries + 1i32;
if tries_0 < 17i32 {
job.tries = tries_0;
let mut time_offset: time_t = get_backoff_time_offset(tries_0);
job.desired_timestamp = job.added_timestamp + time_offset;
dc_job_update(context, &mut job);
dc_log_info(context, 0i32,
} else if job.try_again == -1i32 || job.try_again == 3i32 {
let mut tries_0: libc::c_int = job.tries + 1i32;
if tries_0 < 17i32 {
job.tries = tries_0;
let mut time_offset: time_t = get_backoff_time_offset(tries_0);
job.desired_timestamp = job.added_timestamp + time_offset;
dc_job_update(context, &mut job);
dc_log_info(context, 0i32,
b"%s-job #%i not succeeded on try #%i, retry in ADD_TIME+%i (in %i seconds).\x00"
as *const u8 as *const libc::c_char,
if thread == 100i32 {
@@ -216,28 +215,31 @@ unsafe fn dc_job_perform(
time_offset,
job.added_timestamp + time_offset -
time(0 as *mut time_t));
if thread == 5000i32 && tries_0 < 17i32 - 1i32 {
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
(*context).perform_smtp_jobs_needed = 2i32;
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
}
} else {
if job.action == 5901i32 {
dc_set_msg_failed(context, job.foreign_id, job.pending_error);
}
dc_job_delete(context, &mut job);
if thread == 5000i32 && tries_0 < 17i32 - 1i32 {
*context
.smtp_state
.clone()
.0
.lock()
.unwrap()
.perform_jobs_needed = 2i32;
}
if !(0 != probe_network) {
continue;
}
// on dc_maybe_network() we stop trying here;
// these jobs are already tried once.
// otherwise, we just continue with the next job
// to give other jobs a chance being tried at least once.
break;
} else {
if job.action == 5901i32 {
dc_set_msg_failed(context, job.foreign_id, job.pending_error);
}
dc_job_delete(context, &mut job);
}
if !(0 != probe_network) {
continue;
}
// on dc_maybe_network() we stop trying here;
// these jobs are already tried once.
// otherwise, we just continue with the next job
// to give other jobs a chance being tried at least once.
break;
} else {
dc_job_delete(context, &mut job);
}
}
dc_param_unref(job.param);
@@ -246,7 +248,7 @@ unsafe fn dc_job_perform(
}
unsafe fn dc_job_delete(mut context: &dc_context_t, mut job: *const dc_job_t) {
let mut delete_stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM jobs WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(delete_stmt, 1i32, (*job).job_id as libc::c_int);
@@ -270,7 +272,7 @@ unsafe fn get_backoff_time_offset(mut c_tries: libc::c_int) -> time_t {
}
unsafe fn dc_job_update(mut context: &dc_context_t, mut job: *const dc_job_t) {
let mut stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE jobs SET desired_timestamp=?, tries=?, param=? WHERE id=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -282,20 +284,15 @@ unsafe fn dc_job_update(mut context: &dc_context_t, mut job: *const dc_job_t) {
sqlite3_finalize(stmt);
}
unsafe fn dc_suspend_smtp_thread(mut context: &dc_context_t, mut suspend: libc::c_int) {
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
(*context).smtp_suspended = suspend;
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
*context.smtp_suspended.clone().write().unwrap() = suspend;
if 0 != suspend {
loop {
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
if (*context).smtp_doing_jobs == 0i32 {
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
if *context.smtp_doing_jobs.clone().read().unwrap() == 0 {
return;
}
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
usleep((300i32 * 1000i32) as libc::useconds_t);
}
};
}
}
unsafe extern "C" fn dc_job_do_DC_JOB_SEND(mut context: &dc_context_t, mut job: *mut dc_job_t) {
let mut current_block: u64;
@@ -306,14 +303,15 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(mut context: &dc_context_t, mut job:
let mut recipients_list: *mut clist = 0 as *mut clist;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
/* connect to SMTP server, if not yet done */
if 0 == dc_smtp_is_connected((*context).smtp) {
if 0 == dc_smtp_is_connected(&context.smtp.clone().lock().unwrap()) {
let mut loginparam: *mut dc_loginparam_t = dc_loginparam_new();
dc_loginparam_read(
loginparam,
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"configured_\x00" as *const u8 as *const libc::c_char,
);
let mut connected: libc::c_int = dc_smtp_connect((*context).smtp, loginparam);
let mut connected: libc::c_int =
dc_smtp_connect(&mut context.smtp.clone().lock().unwrap(), loginparam);
dc_loginparam_unref(loginparam);
if 0 == connected {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
@@ -373,33 +371,37 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(mut context: &dc_context_t, mut job:
_ => {
/* send message */
if 0 == dc_smtp_send_msg(
(*context).smtp,
&mut context.smtp.clone().lock().unwrap(),
recipients_list,
buf as *const libc::c_char,
buf_bytes,
) {
if 0 != (*job).foreign_id
&& (MAILSMTP_ERROR_EXCEED_STORAGE_ALLOCATION as libc::c_int
== (*(*context).smtp).error_etpan
== (*&mut context.smtp.clone().lock().unwrap()).error_etpan
|| MAILSMTP_ERROR_INSUFFICIENT_SYSTEM_STORAGE
as libc::c_int
== (*(*context).smtp).error_etpan)
== (*context.smtp.clone().lock().unwrap()).error_etpan)
{
dc_set_msg_failed(
context,
(*job).foreign_id,
(*(*context).smtp).error,
(*&mut context.smtp.clone().lock().unwrap()).error,
);
} else {
dc_smtp_disconnect((*context).smtp);
dc_job_try_again_later(job, -1i32, (*(*context).smtp).error);
dc_smtp_disconnect(&mut context.smtp.clone().lock().unwrap());
dc_job_try_again_later(
job,
-1i32,
(*&mut context.smtp.clone().lock().unwrap()).error,
);
}
} else {
dc_delete_file(context, filename);
if 0 != (*job).foreign_id {
dc_update_msg_state(context, (*job).foreign_id, 26i32);
stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"SELECT chat_id FROM msgs WHERE id=?\x00" as *const u8
as *const libc::c_char,
);
@@ -409,7 +411,7 @@ unsafe extern "C" fn dc_job_do_DC_JOB_SEND(mut context: &dc_context_t, mut job:
} else {
0i32
};
((*context).cb)(
(context.cb)(
context,
Event::MSG_DELIVERED,
chat_id as uintptr_t,
@@ -451,9 +453,9 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(mut context: &dc_context_t, mut job: *mut dc
let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
let mut dest_folder: *mut libc::c_char = 0 as *mut libc::c_char;
let mut dest_uid: uint32_t = 0i32 as uint32_t;
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
connect_to_inbox(context);
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
current_block = 2238328302157162973;
} else {
@@ -466,20 +468,25 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(mut context: &dc_context_t, mut job: *mut dc
2473556513754201174 => {
if !(0 == dc_msg_load_from_db(msg, context, (*job).foreign_id)) {
if dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32,
) < 3i32
{
dc_configure_folders(context, (*context).inbox, 0x1i32);
dc_configure_folders(
context,
&mut context.inbox.clone().lock().unwrap(),
0x1i32,
);
}
dest_folder = dc_sqlite3_get_config(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
match dc_imap_move(
(*context).inbox,
context,
&mut context.inbox.clone().lock().unwrap(),
(*msg).server_folder,
(*msg).server_uid,
dest_folder,
@@ -532,10 +539,11 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(mut context: &dc_context_t, mut job: *mut dc
******************************************************************************/
unsafe fn connect_to_inbox(mut context: &dc_context_t) -> libc::c_int {
let mut ret_connected: libc::c_int = 0i32;
ret_connected = dc_connect_to_configured_imap(context, (*context).inbox);
ret_connected =
dc_connect_to_configured_imap(context, &mut context.inbox.clone().lock().unwrap());
if !(0 == ret_connected) {
dc_imap_set_watch_folder(
(*context).inbox,
&mut context.inbox.clone().lock().unwrap(),
b"INBOX\x00" as *const u8 as *const libc::c_char,
);
}
@@ -551,9 +559,9 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(
let mut uid: uint32_t = dc_param_get_int((*job).param, 'z' as i32, 0i32) as uint32_t;
let mut dest_folder: *mut libc::c_char = 0 as *mut libc::c_char;
let mut dest_uid: uint32_t = 0i32 as uint32_t;
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
connect_to_inbox(context);
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
current_block = 2670689566614003383;
} else {
@@ -564,27 +572,42 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(
}
match current_block {
11006700562992250127 => {
if dc_imap_set_seen((*context).inbox, folder, uid) as libc::c_uint
if dc_imap_set_seen(
context,
&mut context.inbox.clone().lock().unwrap(),
folder,
uid,
) as libc::c_uint
== 0i32 as libc::c_uint
{
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
}
if 0 != dc_param_get_int((*job).param, 'M' as i32, 0i32) {
if dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32,
) < 3i32
{
dc_configure_folders(context, (*context).inbox, 0x1i32);
dc_configure_folders(
context,
&mut context.inbox.clone().lock().unwrap(),
0x1i32,
);
}
dest_folder = dc_sqlite3_get_config(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
match dc_imap_move((*context).inbox, folder, uid, dest_folder, &mut dest_uid)
as libc::c_uint
match dc_imap_move(
context,
&mut context.inbox.clone().lock().unwrap(),
folder,
uid,
dest_folder,
&mut dest_uid,
) as libc::c_uint
{
1 => {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
@@ -604,9 +627,9 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(
) {
let mut current_block: u64;
let mut msg: *mut dc_msg_t = dc_msg_new_untyped(context);
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
connect_to_inbox(context);
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
current_block = 17792648348530113339;
} else {
@@ -618,8 +641,12 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(
match current_block {
15240798224410183470 => {
if !(0 == dc_msg_load_from_db(msg, context, (*job).foreign_id)) {
match dc_imap_set_seen((*context).inbox, (*msg).server_folder, (*msg).server_uid)
as libc::c_uint
match dc_imap_set_seen(
context,
&mut context.inbox.clone().lock().unwrap(),
(*msg).server_folder,
(*msg).server_uid,
) as libc::c_uint
{
0 => {}
1 => {
@@ -631,13 +658,14 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(
_ => {
if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
)
{
match dc_imap_set_mdnsent(
(*context).inbox,
context,
&mut context.inbox.clone().lock().unwrap(),
(*msg).server_folder,
(*msg).server_uid,
) as libc::c_uint
@@ -687,13 +715,14 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(
_ => {
if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
)
{
match dc_imap_set_mdnsent(
(*context).inbox,
context,
&mut context.inbox.clone().lock().unwrap(),
(*msg).server_folder,
(*msg).server_uid,
) as libc::c_uint
@@ -762,12 +791,9 @@ unsafe fn dc_send_mdn(mut context: &dc_context_t, mut msg_id: uint32_t) {
out_gossiped: 0,
out_last_added_location_id: 0,
error: 0 as *mut libc::c_char,
context: 0 as &dc_context_t,
context,
};
dc_mimefactory_init(&mut mimefactory, context);
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return;
}
if !(0 == dc_mimefactory_load_mdn(&mut mimefactory, msg_id)
|| 0 == dc_mimefactory_render(&mut mimefactory))
{
@@ -868,7 +894,7 @@ pub unsafe fn dc_job_add(
return;
}
stmt =
dc_sqlite3_prepare((*context).sql,
dc_sqlite3_prepare(&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO jobs (added_timestamp, thread, action, foreign_id, param, desired_timestamp) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(stmt, 1i32, timestamp as sqlite3_int64);
@@ -900,46 +926,35 @@ pub unsafe fn dc_job_add(
};
}
pub unsafe fn dc_interrupt_smtp_idle(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
dc_log_warning(
context,
0i32,
b"Interrupt SMTP-idle: Bad parameters.\x00" as *const u8 as *const libc::c_char,
);
return;
}
dc_log_info(
context,
0i32,
b"Interrupting SMTP-idle...\x00" as *const u8 as *const libc::c_char,
);
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
(*context).perform_smtp_jobs_needed = 1i32;
(*context).smtpidle_condflag = 1i32;
pthread_cond_signal(&mut (*context).smtpidle_cond);
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
let &(ref lock, ref cvar) = &*context.smtpidle.clone();
// (*context).perform_smtp_jobs_needed = 1i32;
*context.perform_smtp_jobs_needed.clone().write().unwrap() = 1;
// pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
let mut started = lock.lock().unwrap();
// (*context).smtpidle_condflag = 1i32;
*started = 1;
// pthread_cond_signal(&mut (*context).smtpidle_cond);
cvar.notify_one();
}
pub unsafe fn dc_interrupt_imap_idle(mut context: &dc_context_t) {
if context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| (*context).inbox.is_null()
{
dc_log_warning(
context,
0i32,
b"Interrupt IMAP-IDLE: Bad parameters.\x00" as *const u8 as *const libc::c_char,
);
return;
}
dc_log_info(
context,
0i32,
b"Interrupting IMAP-IDLE...\x00" as *const u8 as *const libc::c_char,
);
let l = (*context).inboxidle_condmutex.lock().unwrap();
(*context).perform_inbox_jobs_needed = 1i32;
let l = context.inboxidle_condmutex.lock().unwrap();
context.perform_inbox_jobs_needed = 1i32;
drop(l);
dc_imap_interrupt_idle((*context).inbox);
dc_imap_interrupt_idle(&mut context.inbox.clone().lock().unwrap());
}
unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(mut context: &dc_context_t, mut job: *mut dc_job_t) {
let mut current_block: u64;
@@ -961,9 +976,9 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(mut context: &dc_context_t, mut jo
}
/* if this is the last existing part of the message, we delete the message from the server */
if 0 != delete_from_server {
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
connect_to_inbox(context);
if 0 == dc_imap_is_connected((*context).inbox) {
if 0 == dc_imap_is_connected(&mut context.inbox.clone().lock().unwrap()) {
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
current_block = 8913536887710889399;
} else {
@@ -976,7 +991,7 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(mut context: &dc_context_t, mut jo
8913536887710889399 => {}
_ => {
if 0 == dc_imap_delete_msg(
(*context).inbox,
&mut context.inbox.clone().lock().unwrap(),
(*msg).rfc724_mid,
(*msg).server_folder,
(*msg).server_uid,
@@ -1002,11 +1017,8 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(mut context: &dc_context_t, mut jo
}
/* delete all pending jobs with the given action */
pub unsafe fn dc_job_kill_action(mut context: &dc_context_t, mut action: libc::c_int) {
if context.is_null() {
return;
}
let mut stmt: &sqlite3_stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, action);
@@ -1019,7 +1031,7 @@ pub unsafe fn dc_perform_imap_fetch(mut context: &dc_context_t) {
return;
}
if dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"inbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
) == 0i32
@@ -1036,14 +1048,14 @@ pub unsafe fn dc_perform_imap_fetch(mut context: &dc_context_t) {
0i32,
b"INBOX-fetch started...\x00" as *const u8 as *const libc::c_char,
);
dc_imap_fetch((*context).inbox);
if 0 != (*(*context).inbox).should_reconnect {
dc_imap_fetch(&mut context.inbox.clone().lock().unwrap());
if 0 != context.inbox.clone().lock().unwrap().should_reconnect {
dc_log_info(
context,
0i32,
b"INBOX-fetch aborted, starting over...\x00" as *const u8 as *const libc::c_char,
);
dc_imap_fetch((*context).inbox);
dc_imap_fetch(&mut context.inbox.clone().lock().unwrap());
}
dc_log_info(
context,
@@ -1053,12 +1065,9 @@ pub unsafe fn dc_perform_imap_fetch(mut context: &dc_context_t) {
);
}
pub unsafe fn dc_perform_imap_idle(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return;
}
connect_to_inbox(context);
let l = (*context).inboxidle_condmutex.lock().unwrap();
if 0 != (*context).perform_inbox_jobs_needed {
let l = context.inboxidle_condmutex.lock().unwrap();
if 0 != context.perform_inbox_jobs_needed {
dc_log_info(
context,
0i32,
@@ -1074,7 +1083,7 @@ pub unsafe fn dc_perform_imap_idle(mut context: &dc_context_t) {
0i32,
b"INBOX-IDLE started...\x00" as *const u8 as *const libc::c_char,
);
dc_imap_idle((*context).inbox);
dc_imap_idle(&mut context.inbox.clone().lock().unwrap());
dc_log_info(
context,
0i32,
@@ -1082,157 +1091,133 @@ pub unsafe fn dc_perform_imap_idle(mut context: &dc_context_t) {
);
}
pub unsafe fn dc_perform_mvbox_fetch(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return;
}
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_fetch(&mut (*context).mvbox_thread, use_network);
dc_jobthread_fetch(&mut context.mvbox_thread, use_network);
}
pub unsafe fn dc_perform_mvbox_idle(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return;
}
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_idle(&mut (*context).mvbox_thread, use_network);
dc_jobthread_idle(&mut context.mvbox_thread, use_network);
}
pub unsafe fn dc_interrupt_mvbox_idle(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
dc_log_warning(
context,
0i32,
b"Interrupt MVBOX-IDLE: Bad parameters.\x00" as *const u8 as *const libc::c_char,
);
return;
}
dc_jobthread_interrupt_idle(&mut (*context).mvbox_thread);
dc_jobthread_interrupt_idle(&mut context.mvbox_thread);
}
pub unsafe fn dc_perform_sentbox_fetch(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return;
}
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_fetch(&mut (*context).sentbox_thread, use_network);
dc_jobthread_fetch(&mut context.sentbox_thread, use_network);
}
pub unsafe fn dc_perform_sentbox_idle(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
return;
}
let mut use_network: libc::c_int = dc_sqlite3_get_config_int(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_idle(&mut (*context).sentbox_thread, use_network);
dc_jobthread_idle(&mut context.sentbox_thread, use_network);
}
pub unsafe fn dc_interrupt_sentbox_idle(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
dc_log_warning(
context,
0i32,
b"Interrupt SENT-IDLE: Bad parameters.\x00" as *const u8 as *const libc::c_char,
);
return;
}
dc_jobthread_interrupt_idle(&mut (*context).sentbox_thread);
dc_jobthread_interrupt_idle(&mut context.sentbox_thread);
}
pub unsafe fn dc_perform_smtp_jobs(mut context: &dc_context_t) {
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
let mut probe_smtp_network: libc::c_int = (*context).probe_smtp_network;
(*context).probe_smtp_network = 0i32;
(*context).perform_smtp_jobs_needed = 0i32;
if 0 != (*context).smtp_suspended {
dc_log_info(
context,
0i32,
b"SMTP-jobs suspended.\x00" as *const u8 as *const libc::c_char,
);
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
return;
}
(*context).smtp_doing_jobs = 1i32;
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
let probe_smtp_network = {
let &(ref lock, _) = &*context.smtp_state.clone();
let state = lock.lock().unwrap();
let probe_smtp_network = state.probe_network;
state.probe_network = 0;
state.perform_jobs_needed = 0;
if 0 != state.suspended {
dc_log_info(
context,
0i32,
b"SMTP-jobs suspended.\x00" as *const u8 as *const libc::c_char,
);
return;
}
state.doing_jobs = 1;
probe_smtp_network
};
dc_log_info(
context,
0i32,
0,
b"SMTP-jobs started...\x00" as *const u8 as *const libc::c_char,
);
dc_job_perform(context, 5000i32, probe_smtp_network);
dc_job_perform(context, 5000, probe_smtp_network);
dc_log_info(
context,
0i32,
b"SMTP-jobs ended.\x00" as *const u8 as *const libc::c_char,
);
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
(*context).smtp_doing_jobs = 0i32;
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
}
pub unsafe fn dc_perform_smtp_idle(mut context: &dc_context_t) {
if context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint {
dc_log_warning(
context,
0i32,
b"Cannot perform SMTP-idle: Bad parameters.\x00" as *const u8 as *const libc::c_char,
);
return;
{
let &(ref lock, _) = &*context.smtp_state.clone();
let state = lock.lock().unwrap();
state.doing_jobs = 0;
}
}
pub unsafe fn dc_perform_smtp_idle(mut context: &dc_context_t) {
dc_log_info(
context,
0i32,
b"SMTP-idle started...\x00" as *const u8 as *const libc::c_char,
);
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
if (*context).perform_smtp_jobs_needed == 1i32 {
dc_log_info(
context,
0i32,
b"SMTP-idle will not be started because of waiting jobs.\x00" as *const u8
as *const libc::c_char,
);
} else {
let mut r: libc::c_int = 0i32;
let mut wakeup_at: timespec = timespec {
tv_sec: 0,
tv_nsec: 0,
};
memset(
&mut wakeup_at as &timespec as *mut libc::c_void,
0,
::std::mem::size_of::<timespec>(),
);
wakeup_at.tv_sec = get_next_wakeup_time(context, 5000i32) + 1i32 as libc::c_long;
while (*context).smtpidle_condflag == 0i32 && r == 0i32 {
r = pthread_cond_timedwait(
&mut (*context).smtpidle_cond,
&mut (*context).smtpidle_condmutex,
&mut wakeup_at,
)
{
let &(ref lock, ref cvar) = &*context.smtp_state.clone();
let mut state = lock.lock().unwrap();
if state.perform_jobs_needed == 1 {
dc_log_info(
context,
0,
b"SMTP-idle will not be started because of waiting jobs.\x00" as *const u8
as *const libc::c_char,
);
} else {
let mut r = false;
// FIXME: correct time based on
// get_next_wakeup_time(context, 5000) + 1;
let dur = Duration::from_milis(5000).unwrap();
loop {
let res = cvar.wait_timeout(state, dur);
state = res.0;
if state.idle == true || res.1 {
// We received the notification and the value has been updated, we can leave.
break;
}
}
state.idle = false;
}
(*context).smtpidle_condflag = 0i32
}
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
dc_log_info(
context,
0i32,
b"SMTP-idle ended.\x00" as *const u8 as *const libc::c_char,
);
}
unsafe fn get_next_wakeup_time(mut context: &dc_context_t, mut thread: libc::c_int) -> time_t {
let mut wakeup_time: time_t = 0i32 as time_t;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -1247,11 +1232,11 @@ unsafe fn get_next_wakeup_time(mut context: &dc_context_t, mut thread: libc::c_i
return wakeup_time;
}
pub unsafe fn dc_maybe_network(mut context: &dc_context_t) {
pthread_mutex_lock(&mut (*context).smtpidle_condmutex);
(*context).probe_smtp_network = 1i32;
pthread_mutex_unlock(&mut (*context).smtpidle_condmutex);
let l = (*context).inboxidle_condmutex.lock().unwrap();
(*context).probe_imap_network = 1i32;
pthread_mutex_lock(&mut context.smtpidle_condmutex);
context.probe_smtp_network = 1i32;
pthread_mutex_unlock(&mut context.smtpidle_condmutex);
let l = context.inboxidle_condmutex.lock().unwrap();
context.probe_imap_network = 1i32;
drop(l);
dc_interrupt_smtp_idle(context);
dc_interrupt_imap_idle(context);
@@ -1265,7 +1250,7 @@ pub unsafe fn dc_job_action_exists(
let mut job_exists: libc::c_int = 0i32;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, action);

4
src/dc_location.rs
View File

@@ -833,8 +833,8 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
sqlite3_finalize(stmt_locations);
}
pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
mut context: *mut dc_context_t,
mut job: *mut dc_job_t,
mut context: &dc_context_t,
mut job: &mut dc_job_t,
) {
// this function is called when location-streaming _might_ have ended for a chat.
// the function checks, if location-streaming is really ended;

2
src/dc_smtp.rs
View File

@@ -48,7 +48,7 @@ pub unsafe fn dc_smtp_disconnect(smtp: &mut dc_smtp_t) {
}
}
pub unsafe fn dc_smtp_is_connected(smtp: *const dc_smtp_t) -> libc::c_int {
pub unsafe fn dc_smtp_is_connected(smtp: &dc_smtp_t) -> libc::c_int {
if !smtp.etpan.is_null() {
1
} else {