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

Merge branch 'flub-sqlite' into merge1

Browse Source
This commit is contained in:
holger krekel
2019-07-17 12:07:15 +02:00
parent ad4be80b4e ab48745cc9
commit caac871092
45 changed files with 6930 additions and 9424 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
.circleci/config.yml
View File

@@ -175,12 +175,17 @@ workflows:
requires: requires:
- cargo_fetch - cargo_fetch
# Linux Desktop # Linux Desktop 64bit
- test_x86_64-unknown-linux-gnu: - test_x86_64-unknown-linux-gnu:
requires: requires:
- cargo_fetch - cargo_fetch
# Linux Desktop # Linux Desktop 32bit
# - test_i686-unknown-linux-gnu:
# requires:
# - cargo_fetch
# Android 64bit
# - test_aarch64-linux-android: # - test_aarch64-linux-android:
# requires: # requires:
# - cargo_fetch # - cargo_fetch

5
Cargo.toml
View File

@@ -16,7 +16,6 @@ hex = "0.3.2"
sha2 = "0.8.0" sha2 = "0.8.0"
rand = "0.6.5" rand = "0.6.5"
smallvec = "0.6.9" smallvec = "0.6.9"
libsqlite3-sys = { version = "0.14.0", features = ["bundled", "min_sqlite_version_3_7_16"] }
reqwest = "0.9.15" reqwest = "0.9.15"
num-derive = "0.2.5" num-derive = "0.2.5"
num-traits = "0.2.6" num-traits = "0.2.6"
@@ -36,6 +35,10 @@ failure_derive = "0.1.5"
rustyline = "4.1.0" rustyline = "4.1.0"
lazy_static = "1.3.0" lazy_static = "1.3.0"
regex = "1.1.6" regex = "1.1.6"
rusqlite = { version = "0.19", features = ["bundled"] }
addr = "0.2.0"
r2d2_sqlite = "0.11.0"
r2d2 = "0.8.5"
[dev-dependencies] [dev-dependencies]
tempfile = "3.0" tempfile = "3.0"

5
appveyor.yml
View File

@@ -1,11 +1,10 @@
environment: environment:
matrix: matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TARGET: x86_64-pc-windows-msvc
install: install:
- appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
- rustup-init -yv --default-host %target% --default-toolchain none - rustup-init -yv --default-toolchain nightly-2019-07-10
- set PATH=%PATH%;%USERPROFILE%\.cargo\bin - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
- rustc -vV - rustc -vV
- cargo -vV - cargo -vV
@@ -14,7 +13,7 @@ install:
build: false build: false
test_script: test_script:
- cargo test --release - cargo test --release
cache: cache:
- target - target

34
deltachat-ffi/src/lib.rs
View File

@@ -88,9 +88,10 @@ pub unsafe extern "C" fn dc_set_config(
value: *mut libc::c_char, value: *mut libc::c_char,
) -> libc::c_int { ) -> libc::c_int {
assert!(!context.is_null()); assert!(!context.is_null());
assert!(!key.is_null(), "invalid key");
let context = &*context; let context = &*context;
context::dc_set_config(context, key, value) context::dc_set_config(context, dc_tools::as_str(key), as_opt_str(value))
} }
#[no_mangle] #[no_mangle]
@@ -99,9 +100,10 @@ pub unsafe extern "C" fn dc_get_config(
key: *mut libc::c_char, key: *mut libc::c_char,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
assert!(!context.is_null()); assert!(!context.is_null());
assert!(!key.is_null(), "invalid key");
let context = &*context; let context = &*context;
context::dc_get_config(context, key) into_cstring(context::dc_get_config(context, dc_tools::as_str(key)))
} }
#[no_mangle] #[no_mangle]
@@ -411,7 +413,7 @@ pub unsafe extern "C" fn dc_marknoticed_chat(context: *mut dc_context_t, chat_id
assert!(!context.is_null()); assert!(!context.is_null());
let context = &*context; let context = &*context;
dc_chat::dc_marknoticed_chat(context, chat_id) dc_chat::dc_marknoticed_chat(context, chat_id);
} }
#[no_mangle] #[no_mangle]
@@ -419,7 +421,7 @@ pub unsafe extern "C" fn dc_marknoticed_all_chats(context: *mut dc_context_t) {
assert!(!context.is_null()); assert!(!context.is_null());
let context = &*context; let context = &*context;
dc_chat::dc_marknoticed_all_chats(context) dc_chat::dc_marknoticed_all_chats(context);
} }
#[no_mangle] #[no_mangle]
@@ -460,7 +462,7 @@ pub unsafe extern "C" fn dc_archive_chat(
assert!(!context.is_null()); assert!(!context.is_null());
let context = &*context; let context = &*context;
dc_chat::dc_archive_chat(context, chat_id, archive) dc_chat::dc_archive_chat(context, chat_id, archive);
} }
#[no_mangle] #[no_mangle]
@@ -641,7 +643,7 @@ pub unsafe extern "C" fn dc_markseen_msgs(
assert!(!context.is_null()); assert!(!context.is_null());
let context = &*context; let context = &*context;
dc_msg::dc_markseen_msgs(context, msg_ids, msg_cnt) dc_msg::dc_markseen_msgs(context, msg_ids, msg_cnt as usize);
} }
#[no_mangle] #[no_mangle]
@@ -654,7 +656,7 @@ pub unsafe extern "C" fn dc_star_msgs(
assert!(!context.is_null()); assert!(!context.is_null());
let context = &*context; let context = &*context;
dc_msg::dc_star_msgs(context, msg_ids, msg_cnt, star) dc_msg::dc_star_msgs(context, msg_ids, msg_cnt, star);
} }
#[no_mangle] #[no_mangle]
@@ -887,7 +889,7 @@ pub unsafe extern "C" fn dc_is_sending_locations_to_chat(
assert!(!context.is_null()); assert!(!context.is_null());
let context = &*context; let context = &*context;
dc_location::dc_is_sending_locations_to_chat(context, chat_id) dc_location::dc_is_sending_locations_to_chat(context, chat_id) as libc::c_int
} }
#[no_mangle] #[no_mangle]
@@ -928,7 +930,7 @@ pub unsafe extern "C" fn dc_delete_all_locations(context: *mut dc_context_t) {
assert!(!context.is_null()); assert!(!context.is_null());
let context = &*context; let context = &*context;
dc_location::dc_delete_all_locations(context) dc_location::dc_delete_all_locations(context);
} }
// dc_array_t // dc_array_t
@@ -1337,7 +1339,7 @@ pub unsafe extern "C" fn dc_msg_is_increation(msg: *mut dc_msg::dc_msg_t) -> lib
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn dc_msg_is_setupmessage(msg: *mut dc_msg::dc_msg_t) -> libc::c_int { pub unsafe extern "C" fn dc_msg_is_setupmessage(msg: *mut dc_msg::dc_msg_t) -> libc::c_int {
dc_msg::dc_msg_is_setupmessage(msg) dc_msg::dc_msg_is_setupmessage(msg) as libc::c_int
} }
#[no_mangle] #[no_mangle]
@@ -1524,3 +1526,15 @@ pub unsafe extern "C" fn dc_lot_get_timestamp(lot: *mut dc_lot::dc_lot_t) -> i64
pub unsafe extern "C" fn dc_str_unref(s: *mut libc::c_char) { pub unsafe extern "C" fn dc_str_unref(s: *mut libc::c_char) {
libc::free(s as *mut _) libc::free(s as *mut _)
} }
fn as_opt_str<'a>(s: *const libc::c_char) -> Option<&'a str> {
if s.is_null() {
return None;
}
Some(dc_tools::as_str(s))
}
unsafe fn into_cstring(s: impl AsRef<str>) -> *mut libc::c_char {
dc_tools::dc_strdup(dc_tools::to_cstring(s).as_ptr())
}

98
examples/repl/cmdline.rs
View File

@@ -12,9 +12,9 @@ use deltachat::dc_lot::*;
use deltachat::dc_msg::*; use deltachat::dc_msg::*;
use deltachat::dc_qr::*; use deltachat::dc_qr::*;
use deltachat::dc_receive_imf::*; use deltachat::dc_receive_imf::*;
use deltachat::dc_sqlite3::*;
use deltachat::dc_tools::*; use deltachat::dc_tools::*;
use deltachat::peerstate::*; use deltachat::peerstate::*;
use deltachat::sql;
use deltachat::types::*; use deltachat::types::*;
use deltachat::x::*; use deltachat::x::*;
use num_traits::FromPrimitive; use num_traits::FromPrimitive;
@@ -25,65 +25,58 @@ use num_traits::FromPrimitive;
pub unsafe fn dc_reset_tables(context: &Context, bits: i32) -> i32 { pub unsafe fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
info!(context, 0, "Resetting tables ({})...", bits); info!(context, 0, "Resetting tables ({})...", bits);
if 0 != bits & 1 { if 0 != bits & 1 {
dc_sqlite3_execute( sql::execute(context, &context.sql, "DELETE FROM jobs;", params![]);
context,
&context.sql,
b"DELETE FROM jobs;\x00" as *const u8 as *const libc::c_char,
);
info!(context, 0, "(1) Jobs reset."); info!(context, 0, "(1) Jobs reset.");
} }
if 0 != bits & 2 { if 0 != bits & 2 {
dc_sqlite3_execute( sql::execute(
context, context,
&context.sql, &context.sql,
b"DELETE FROM acpeerstates;\x00" as *const u8 as *const libc::c_char, "DELETE FROM acpeerstates;",
params![],
); );
info!(context, 0, "(2) Peerstates reset."); info!(context, 0, "(2) Peerstates reset.");
} }
if 0 != bits & 4 { if 0 != bits & 4 {
dc_sqlite3_execute( sql::execute(context, &context.sql, "DELETE FROM keypairs;", params![]);
context,
&context.sql,
b"DELETE FROM keypairs;\x00" as *const u8 as *const libc::c_char,
);
info!(context, 0, "(4) Private keypairs reset."); info!(context, 0, "(4) Private keypairs reset.");
} }
if 0 != bits & 8 { if 0 != bits & 8 {
dc_sqlite3_execute( sql::execute(
context, context,
&context.sql, &context.sql,
b"DELETE FROM contacts WHERE id>9;\x00" as *const u8 as *const libc::c_char, "DELETE FROM contacts WHERE id>9;",
params![],
); );
dc_sqlite3_execute( sql::execute(
context, context,
&context.sql, &context.sql,
b"DELETE FROM chats WHERE id>9;\x00" as *const u8 as *const libc::c_char, "DELETE FROM chats WHERE id>9;",
params![],
); );
dc_sqlite3_execute( sql::execute(
context, context,
&context.sql, &context.sql,
b"DELETE FROM chats_contacts;\x00" as *const u8 as *const libc::c_char, "DELETE FROM chats_contacts;",
params![],
); );
dc_sqlite3_execute( sql::execute(
context, context,
&context.sql, &context.sql,
b"DELETE FROM msgs WHERE id>9;\x00" as *const u8 as *const libc::c_char, "DELETE FROM msgs WHERE id>9;",
params![],
); );
dc_sqlite3_execute( sql::execute(
context, context,
&context.sql, &context.sql,
b"DELETE FROM config WHERE keyname LIKE \'imap.%\' OR keyname LIKE \'configured%\';\x00" "DELETE FROM config WHERE keyname LIKE \'imap.%\' OR keyname LIKE \'configured%\';",
as *const u8 as *const libc::c_char, params![],
);
dc_sqlite3_execute(
context,
&context.sql,
b"DELETE FROM leftgrps;\x00" as *const u8 as *const libc::c_char,
); );
sql::execute(context, &context.sql, "DELETE FROM leftgrps;", params![]);
info!(context, 0, "(8) Rest but server config reset."); info!(context, 0, "(8) Rest but server config reset.");
} }
context.call_cb(Event::MSGS_CHANGED, 0 as uintptr_t, 0 as uintptr_t); context.call_cb(Event::MSGS_CHANGED, 0, 0);
1 1
} }
@@ -100,14 +93,7 @@ unsafe fn dc_poke_eml_file(context: &Context, filename: *const libc::c_char) ->
&mut data_bytes, &mut data_bytes,
) == 0i32) ) == 0i32)
{ {
dc_receive_imf( dc_receive_imf(context, data, data_bytes, "import", 0, 0);
context,
data,
data_bytes,
b"import\x00" as *const u8 as *const libc::c_char,
0i32 as uint32_t,
0i32 as uint32_t,
);
success = 1; success = 1;
} }
free(data as *mut libc::c_void); free(data as *mut libc::c_void);
@@ -138,26 +124,22 @@ unsafe fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int
/* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */ /* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */
if !spec.is_null() { if !spec.is_null() {
real_spec = dc_strdup(spec); real_spec = dc_strdup(spec);
dc_sqlite3_set_config( sql::set_config(
context, context,
&context.sql, &context.sql,
b"import_spec\x00" as *const u8 as *const libc::c_char, "import_spec",
real_spec, Some(as_str(real_spec)),
); );
current_block = 7149356873433890176; current_block = 7149356873433890176;
} else { } else {
real_spec = dc_sqlite3_get_config( let rs = sql::get_config(context, &context.sql, "import_spec", None);
context, if rs.is_none() {
&context.sql,
b"import_spec\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if real_spec.is_null() {
error!(context, 0, "Import: No file or folder given."); error!(context, 0, "Import: No file or folder given.");
current_block = 8522321847195001863; current_block = 8522321847195001863;
} else { } else {
current_block = 7149356873433890176; current_block = 7149356873433890176;
} }
real_spec = strdup(to_cstring(rs.unwrap_or_default()).as_ptr());
} }
match current_block { match current_block {
8522321847195001863 => {} 8522321847195001863 => {}
@@ -499,9 +481,8 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
}, },
"auth" => { "auth" => {
if 0 == S_IS_AUTH { if 0 == S_IS_AUTH {
let is_pw = let is_pw = dc_get_config(context, "mail_pw");
dc_get_config(context, b"mail_pw\x00" as *const u8 as *const libc::c_char); if arg1 == is_pw {
if arg1 == as_str(is_pw) {
S_IS_AUTH = 1; S_IS_AUTH = 1;
} else { } else {
println!("Bad password."); println!("Bad password.");
@@ -537,8 +518,8 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
ensure!(!arg1.is_empty(), "Argument <msg-id> missing."); ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
let msg_id: u32 = arg1.parse().unwrap(); let msg_id: u32 = arg1.parse().unwrap();
let msg: *mut dc_msg_t = dc_get_msg(context, msg_id); let msg: *mut dc_msg_t = dc_get_msg(context, msg_id);
if 0 != dc_msg_is_setupmessage(msg) { if dc_msg_is_setupmessage(msg) {
let setupcodebegin: *mut libc::c_char = dc_msg_get_setupcodebegin(msg); let setupcodebegin = dc_msg_get_setupcodebegin(msg);
println!( println!(
"The setup code for setup message Msg#{} starts with: {}", "The setup code for setup message Msg#{} starts with: {}",
msg_id, msg_id,
@@ -621,15 +602,14 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
"set" => { "set" => {
ensure!(!arg1.is_empty(), "Argument <key> missing."); ensure!(!arg1.is_empty(), "Argument <key> missing.");
ensure!( ensure!(
0 != dc_set_config(context, arg1_c_ptr, arg2_c_ptr), 0 != dc_set_config(context, &arg1, Some(&arg2)),
"Set config failed" "Set config failed"
); );
} }
"get" => { "get" => {
ensure!(!arg1.is_empty(), "Argument <key> missing."); ensure!(!arg1.is_empty(), "Argument <key> missing.");
let val = dc_get_config(context, arg1_c_ptr); let val = dc_get_config(context, &arg1);
println!("{}={}", arg1, to_string(val)); println!("{}={}", arg1, val);
free(val as *mut libc::c_void);
} }
"info" => { "info" => {
println!("{}", to_string(dc_get_info(context))); println!("{}", to_string(dc_get_info(context)));
@@ -638,7 +618,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
dc_maybe_network(context); dc_maybe_network(context);
} }
"housekeeping" => { "housekeeping" => {
dc_housekeeping(context); sql::housekeeping(context);
} }
"listchats" | "listarchived" | "chats" => { "listchats" | "listarchived" | "chats" => {
let listflags = if arg0 == "listarchived" { 0x01 } else { 0 }; let listflags = if arg0 == "listarchived" { 0x01 } else { 0 };
@@ -714,7 +694,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
i -= 1 i -= 1
} }
} }
if 0 != dc_is_sending_locations_to_chat(context, 0 as uint32_t) { if dc_is_sending_locations_to_chat(context, 0 as uint32_t) {
info!(context, 0, "Location streaming enabled."); info!(context, 0, "Location streaming enabled.");
} }
println!("{} chats", cnt); println!("{} chats", cnt);

14
examples/repl/main.rs
View File

@@ -10,6 +10,8 @@ extern crate deltachat;
extern crate failure; extern crate failure;
#[macro_use] #[macro_use]
extern crate lazy_static; extern crate lazy_static;
#[macro_use]
extern crate rusqlite;
use std::borrow::Cow::{self, Borrowed, Owned}; use std::borrow::Cow::{self, Borrowed, Owned};
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
@@ -512,25 +514,21 @@ unsafe fn handle_cmd(line: &str, ctx: Arc<RwLock<Context>>) -> Result<ExitResult
dc_configure(&ctx.read().unwrap()); dc_configure(&ctx.read().unwrap());
} }
"oauth2" => { "oauth2" => {
let addr = dc_get_config( let addr = dc_get_config(&ctx.read().unwrap(), "addr");
&ctx.read().unwrap(), if addr.is_empty() {
b"addr\x00" as *const u8 as *const libc::c_char,
);
if addr.is_null() || *addr.offset(0isize) as libc::c_int == 0i32 {
println!("oauth2: set addr first."); println!("oauth2: set addr first.");
} else { } else {
let oauth2_url = dc_get_oauth2_url( let oauth2_url = dc_get_oauth2_url(
&ctx.read().unwrap(), &ctx.read().unwrap(),
as_str(addr), &addr,
"chat.delta:/com.b44t.messenger", "chat.delta:/com.b44t.messenger",
); );
if oauth2_url.is_none() { if oauth2_url.is_none() {
println!("OAuth2 not available for {}.", to_string(addr)); println!("OAuth2 not available for {}.", &addr);
} else { } else {
println!("Open the following url, set mail_pw to the generated token and server_flags to 2:\n{}", oauth2_url.unwrap()); println!("Open the following url, set mail_pw to the generated token and server_flags to 2:\n{}", oauth2_url.unwrap());
} }
} }
free(addr as *mut libc::c_void);
} }
"clear" => { "clear" => {
println!("\n\n\n"); println!("\n\n\n");

18
examples/simple.rs
View File

@@ -79,20 +79,14 @@ fn main() {
println!("opening database {:?}", dbfile); println!("opening database {:?}", dbfile);
dc_open(&ctx, dbfile.as_ptr(), std::ptr::null()); assert_eq!(dc_open(&ctx, dbfile.as_ptr(), std::ptr::null()), 1);
println!("configuring"); println!("configuring");
let pw = std::env::args().collect::<Vec<String>>()[1].clone(); let args = std::env::args().collect::<Vec<String>>();
dc_set_config( assert_eq!(args.len(), 2, "missing password");
&ctx, let pw = args[1].clone();
CString::new("addr").unwrap().as_ptr(), dc_set_config(&ctx, "addr", Some("d@testrun.org"));
CString::new("d@testrun.org").unwrap().as_ptr(), dc_set_config(&ctx, "mail_pw", Some(&pw));
);
dc_set_config(
&ctx,
CString::new("mail_pw").unwrap().as_ptr(),
CString::new(pw).unwrap().as_ptr(),
);
dc_configure(&ctx); dc_configure(&ctx);
thread::sleep(duration); thread::sleep(duration);

2
rust-toolchain
View File

@@ -1 +1 @@
nightly-2019-06-16 nightly-2019-07-10

7
src/aheader.rs
View File

@@ -1,5 +1,5 @@
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::ffi::{CStr, CString}; use std::ffi::CStr;
use std::str::FromStr; use std::str::FromStr;
use std::{fmt, str}; use std::{fmt, str};
@@ -7,6 +7,7 @@ use mmime::mailimf_types::*;
use crate::constants::*; use crate::constants::*;
use crate::dc_contact::*; use crate::dc_contact::*;
use crate::dc_tools::as_str;
use crate::key::*; use crate::key::*;
/// Possible values for encryption preference /// Possible values for encryption preference
@@ -93,9 +94,7 @@ impl Aheader {
match Self::from_str(value) { match Self::from_str(value) {
Ok(test) => { Ok(test) => {
// TODO: implement rust-safe version of dc_addr_cmp if dc_addr_cmp(&test.addr, as_str(wanted_from)) {
let addr = CString::new(test.addr.clone()).unwrap();
if unsafe { dc_addr_cmp(addr.as_ptr(), wanted_from) } == 0 {
if fine_header.is_none() { if fine_header.is_none() {
fine_header = Some(test); fine_header = Some(test);
} else { } else {

738
src/context.rs
View File

@@ -6,27 +6,69 @@ use crate::dc_chat::*;
use crate::dc_contact::*; use crate::dc_contact::*;
use crate::dc_job::*; use crate::dc_job::*;
use crate::dc_jobthread::*; use crate::dc_jobthread::*;
use crate::dc_log::*;
use crate::dc_loginparam::*; use crate::dc_loginparam::*;
use crate::dc_lot::dc_lot_t; use crate::dc_lot::dc_lot_t;
use crate::dc_move::*; use crate::dc_move::*;
use crate::dc_msg::*; use crate::dc_msg::*;
use crate::dc_receive_imf::*; use crate::dc_receive_imf::*;
use crate::dc_sqlite3::*;
use crate::dc_stock::*; use crate::dc_stock::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::imap::*; use crate::imap::*;
use crate::key::*; use crate::key::*;
use crate::smtp::*; use crate::smtp::*;
use crate::sql::{self, Sql};
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
const CONFIG_KEYS: [&'static str; 33] = [
"addr",
"mail_server",
"mail_user",
"mail_pw",
"mail_port",
"send_server",
"send_user",
"send_pw",
"send_port",
"server_flags",
"imap_folder",
"displayname",
"selfstatus",
"selfavatar",
"e2ee_enabled",
"mdns_enabled",
"inbox_watch",
"sentbox_watch",
"mvbox_watch",
"mvbox_move",
"show_emails",
"save_mime_headers",
"configured_addr",
"configured_mail_server",
"configured_mail_user",
"configured_mail_pw",
"configured_mail_port",
"configured_send_server",
"configured_send_user",
"configured_send_pw",
"configured_send_port",
"configured_server_flags",
"configured",
];
// deprecated
const SYS_CONFIG_KEYS: [&'static str; 3] = [
"sys.version",
"sys.msgsize_max_recommended",
"sys.config_keys",
];
#[repr(C)] #[repr(C)]
pub struct Context { pub struct Context {
pub userdata: *mut libc::c_void, pub userdata: *mut libc::c_void,
pub dbfile: Arc<RwLock<*mut libc::c_char>>, pub dbfile: Arc<RwLock<*mut libc::c_char>>,
pub blobdir: Arc<RwLock<*mut libc::c_char>>, pub blobdir: Arc<RwLock<*mut libc::c_char>>,
pub sql: SQLite, pub sql: Sql,
pub inbox: Arc<RwLock<Imap>>, pub inbox: Arc<RwLock<Imap>>,
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>>,
@@ -150,7 +192,7 @@ pub fn dc_context_new(
cb, cb,
os_name: unsafe { dc_strdup_keep_null(os_name) }, os_name: unsafe { dc_strdup_keep_null(os_name) },
running_state: Arc::new(RwLock::new(Default::default())), running_state: Arc::new(RwLock::new(Default::default())),
sql: SQLite::new(), sql: Sql::new(),
smtp: Arc::new(Mutex::new(Smtp::new())), smtp: Arc::new(Mutex::new(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(())),
@@ -187,7 +229,7 @@ unsafe fn cb_receive_imf(
context: &Context, context: &Context,
imf_raw_not_terminated: *const libc::c_char, imf_raw_not_terminated: *const libc::c_char,
imf_raw_bytes: size_t, imf_raw_bytes: size_t,
server_folder: *const libc::c_char, server_folder: &str,
server_uid: uint32_t, server_uid: uint32_t,
flags: uint32_t, flags: uint32_t,
) { ) {
@@ -204,7 +246,7 @@ unsafe fn cb_receive_imf(
unsafe fn cb_precheck_imf( unsafe fn cb_precheck_imf(
context: &Context, context: &Context,
rfc724_mid: *const libc::c_char, rfc724_mid: *const libc::c_char,
server_folder: *const libc::c_char, server_folder: &str,
server_uid: uint32_t, server_uid: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut rfc724_mid_exists: libc::c_int = 0i32; let mut rfc724_mid_exists: libc::c_int = 0i32;
@@ -223,23 +265,23 @@ unsafe fn cb_precheck_imf(
if *old_server_folder.offset(0isize) as libc::c_int == 0i32 if *old_server_folder.offset(0isize) as libc::c_int == 0i32
&& old_server_uid == 0i32 as libc::c_uint && old_server_uid == 0i32 as libc::c_uint
{ {
dc_log_info( info!(
context, context,
0i32, 0,
b"[move] detected bbc-self %s\x00" as *const u8 as *const libc::c_char, "[move] detected bbc-self {}",
rfc724_mid, as_str(rfc724_mid),
); );
mark_seen = 1i32 mark_seen = 1i32
} else if strcmp(old_server_folder, server_folder) != 0i32 { } else if as_str(old_server_folder) != server_folder {
dc_log_info( info!(
context, context,
0i32, 0,
b"[move] detected moved message %s\x00" as *const u8 as *const libc::c_char, "[move] detected moved message {}",
rfc724_mid, as_str(rfc724_mid),
); );
dc_update_msg_move_state(context, rfc724_mid, DC_MOVE_STATE_STAY); dc_update_msg_move_state(context, rfc724_mid, DC_MOVE_STATE_STAY);
} }
if strcmp(old_server_folder, server_folder) != 0i32 || old_server_uid != server_uid { if as_str(old_server_folder) != server_folder || old_server_uid != server_uid {
dc_update_server_uid(context, rfc724_mid, server_folder, server_uid); dc_update_server_uid(context, rfc724_mid, server_folder, server_uid);
} }
dc_do_heuristics_moves(context, server_folder, msg_id); dc_do_heuristics_moves(context, server_folder, msg_id);
@@ -258,7 +300,12 @@ unsafe fn cb_precheck_imf(
} }
unsafe fn cb_set_config(context: &Context, key: *const libc::c_char, value: *const libc::c_char) { unsafe fn cb_set_config(context: &Context, key: *const libc::c_char, value: *const libc::c_char) {
dc_sqlite3_set_config(context, &context.sql, key, value); let v = if value.is_null() {
None
} else {
Some(as_str(value))
};
sql::set_config(context, &context.sql, as_str(key), v);
} }
/* * /* *
@@ -273,7 +320,17 @@ 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(context, &context.sql, key, def) let d = if def.is_null() {
None
} else {
Some(as_str(def))
};
let res = sql::get_config(context, &context.sql, as_str(key), d);
if let Some(res) = res {
strdup(to_cstring(res).as_ptr())
} else {
std::ptr::null_mut()
}
} }
pub unsafe fn dc_context_unref(context: &mut Context) { pub unsafe fn dc_context_unref(context: &mut Context) {
@@ -361,52 +418,48 @@ pub unsafe fn dc_get_blobdir(context: &Context) -> *mut libc::c_char {
dc_strdup(*context.blobdir.clone().read().unwrap()) dc_strdup(*context.blobdir.clone().read().unwrap())
} }
pub unsafe fn dc_set_config( pub fn dc_set_config(context: &Context, key: impl AsRef<str>, value: Option<&str>) -> libc::c_int {
context: &Context,
key: *const libc::c_char,
value: *const libc::c_char,
) -> libc::c_int {
let mut ret = 0; let mut ret = 0;
let mut rel_path = 0 as *mut libc::c_char;
if key.is_null() || 0 == is_settable_config_key(key) { if !is_settable_config_key(key.as_ref()) {
return 0; return 0;
} }
if strcmp(key, b"selfavatar\x00" as *const u8 as *const libc::c_char) == 0 && !value.is_null() {
rel_path = dc_strdup(value); match key.as_ref() {
if !(0 == dc_make_rel_and_copy(context, &mut rel_path)) { "selfavatar" if value.is_some() => {
ret = dc_sqlite3_set_config(context, &context.sql, key, rel_path) let mut rel_path = unsafe { dc_strdup(to_cstring(value.unwrap()).as_ptr()) };
if 0 != unsafe { dc_make_rel_and_copy(context, &mut rel_path) } {
ret = sql::set_config(context, &context.sql, key, Some(as_str(rel_path)));
} }
} else if strcmp(key, b"inbox_watch\x00" as *const u8 as *const libc::c_char) == 0 { unsafe { free(rel_path as *mut libc::c_void) };
ret = dc_sqlite3_set_config(context, &context.sql, key, value); }
dc_interrupt_imap_idle(context); "inbox_watch" => {
} else if strcmp( ret = sql::set_config(context, &context.sql, key, value);
key, unsafe { dc_interrupt_imap_idle(context) };
b"sentbox_watch\x00" as *const u8 as *const libc::c_char, }
) == 0 "sentbox_watch" => {
{ ret = sql::set_config(context, &context.sql, key, value);
ret = dc_sqlite3_set_config(context, &context.sql, key, value); unsafe { dc_interrupt_sentbox_idle(context) };
dc_interrupt_sentbox_idle(context); }
} else if strcmp(key, b"mvbox_watch\x00" as *const u8 as *const libc::c_char) == 0 { "mvbox_watch" => {
ret = dc_sqlite3_set_config(context, &context.sql, key, value); ret = sql::set_config(context, &context.sql, key, value);
dc_interrupt_mvbox_idle(context); unsafe { dc_interrupt_mvbox_idle(context) };
} else if strcmp(key, b"selfstatus\x00" as *const u8 as *const libc::c_char) == 0 { }
let def = dc_stock_str(context, 13); "selfstatus" => {
ret = dc_sqlite3_set_config( let def = unsafe { dc_stock_str(context, 13) };
context, let val = if value.is_none() || value.unwrap() == as_str(def) {
&context.sql, None
key,
if value.is_null() || strcmp(value, def) == 0 {
0 as *const libc::c_char
} else { } else {
value value
}, };
);
free(def as *mut libc::c_void); ret = sql::set_config(context, &context.sql, key, val);
} else { unsafe { free(def as *mut libc::c_void) };
ret = dc_sqlite3_set_config(context, &context.sql, key, value); }
_ => {
ret = sql::set_config(context, &context.sql, key, value);
}
} }
free(rel_path as *mut libc::c_void);
ret ret
} }
@@ -414,303 +467,135 @@ pub unsafe fn dc_set_config(
* INI-handling, Information * INI-handling, Information
******************************************************************************/ ******************************************************************************/
unsafe fn is_settable_config_key(key: *const libc::c_char) -> libc::c_int { fn is_settable_config_key(key: impl AsRef<str>) -> bool {
let mut i = 0; CONFIG_KEYS
while i .into_iter()
< (::std::mem::size_of::<[*const libc::c_char; 33]>()) .find(|c| **c == key.as_ref())
.wrapping_div(::std::mem::size_of::<*mut libc::c_char>()) .is_some()
{
if strcmp(key, config_keys[i as usize]) == 0 {
return 1;
}
i += 1
}
0
} }
static mut config_keys: [*const libc::c_char; 33] = [ pub fn dc_get_config(context: &Context, key: impl AsRef<str>) -> String {
b"addr\x00" as *const u8 as *const libc::c_char, if key.as_ref().starts_with("sys") {
b"mail_server\x00" as *const u8 as *const libc::c_char, return get_sys_config_str(key.as_ref());
b"mail_user\x00" as *const u8 as *const libc::c_char,
b"mail_pw\x00" as *const u8 as *const libc::c_char,
b"mail_port\x00" as *const u8 as *const libc::c_char,
b"send_server\x00" as *const u8 as *const libc::c_char,
b"send_user\x00" as *const u8 as *const libc::c_char,
b"send_pw\x00" as *const u8 as *const libc::c_char,
b"send_port\x00" as *const u8 as *const libc::c_char,
b"server_flags\x00" as *const u8 as *const libc::c_char,
b"imap_folder\x00" as *const u8 as *const libc::c_char,
b"displayname\x00" as *const u8 as *const libc::c_char,
b"selfstatus\x00" as *const u8 as *const libc::c_char,
b"selfavatar\x00" as *const u8 as *const libc::c_char,
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
b"inbox_watch\x00" as *const u8 as *const libc::c_char,
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
b"mvbox_move\x00" as *const u8 as *const libc::c_char,
b"show_emails\x00" as *const u8 as *const libc::c_char,
b"save_mime_headers\x00" as *const u8 as *const libc::c_char,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"configured_mail_server\x00" as *const u8 as *const libc::c_char,
b"configured_mail_user\x00" as *const u8 as *const libc::c_char,
b"configured_mail_pw\x00" as *const u8 as *const libc::c_char,
b"configured_mail_port\x00" as *const u8 as *const libc::c_char,
b"configured_send_server\x00" as *const u8 as *const libc::c_char,
b"configured_send_user\x00" as *const u8 as *const libc::c_char,
b"configured_send_pw\x00" as *const u8 as *const libc::c_char,
b"configured_send_port\x00" as *const u8 as *const libc::c_char,
b"configured_server_flags\x00" as *const u8 as *const libc::c_char,
b"configured\x00" as *const u8 as *const libc::c_char,
];
pub unsafe fn dc_get_config(context: &Context, key: *const libc::c_char) -> *mut libc::c_char {
let mut value = 0 as *mut libc::c_char;
if !key.is_null()
&& *key.offset(0isize) as libc::c_int == 's' as i32
&& *key.offset(1isize) as libc::c_int == 'y' as i32
&& *key.offset(2isize) as libc::c_int == 's' as i32
&& *key.offset(3isize) as libc::c_int == '.' as i32
{
return get_sys_config_str(key);
} }
if key.is_null() || 0 == is_gettable_config_key(key) { if !is_gettable_config_key(key.as_ref()) {
return dc_strdup(b"\x00" as *const u8 as *const libc::c_char); return "".into();
} }
if strcmp(key, b"selfavatar\x00" as *const u8 as *const libc::c_char) == 0 { let value = match key.as_ref() {
let rel_path: *mut libc::c_char = "selfavatar" => {
dc_sqlite3_get_config(context, &context.sql, key, 0 as *const libc::c_char); let rel_path = sql::get_config(context, &context.sql, key.as_ref(), None);
if !rel_path.is_null() { rel_path.map(|p| {
value = dc_get_abs_path(context, rel_path); let v = unsafe { dc_get_abs_path(context, to_cstring(p).as_ptr()) };
free(rel_path as *mut libc::c_void); let r = to_string(v);
unsafe { free(v as *mut _) };
r
})
} }
} else { _ => sql::get_config(context, &context.sql, key.as_ref(), None),
value = dc_sqlite3_get_config(context, &context.sql, key, 0 as *const libc::c_char)
}
if value.is_null() {
if strcmp(key, b"e2ee_enabled\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
} else if strcmp(key, b"mdns_enabled\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
} else if strcmp(key, b"imap_folder\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_strdup(b"INBOX\x00" as *const u8 as *const libc::c_char)
} else if strcmp(key, b"inbox_watch\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
} else if strcmp(
key,
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
) == 0
{
value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
} else if strcmp(key, b"mvbox_watch\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
} else if strcmp(key, b"mvbox_move\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 1)
} else if strcmp(key, b"show_emails\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_mprintf(b"%i\x00" as *const u8 as *const libc::c_char, 0)
} else if strcmp(key, b"selfstatus\x00" as *const u8 as *const libc::c_char) == 0 {
value = dc_stock_str(context, 13)
} else {
value = dc_mprintf(b"\x00" as *const u8 as *const libc::c_char)
}
}
value
}
unsafe fn is_gettable_config_key(key: *const libc::c_char) -> libc::c_int {
let mut i = 0;
while i
< (::std::mem::size_of::<[*const libc::c_char; 3]>())
.wrapping_div(::std::mem::size_of::<*mut libc::c_char>())
{
if strcmp(key, sys_config_keys[i as usize]) == 0 {
return 1;
}
i += 1
}
is_settable_config_key(key)
}
// deprecated
static mut sys_config_keys: [*const libc::c_char; 3] = [
b"sys.version\x00" as *const u8 as *const libc::c_char,
b"sys.msgsize_max_recommended\x00" as *const u8 as *const libc::c_char,
b"sys.config_keys\x00" as *const u8 as *const libc::c_char,
];
unsafe fn get_sys_config_str(key: *const libc::c_char) -> *mut libc::c_char {
if strcmp(key, b"sys.version\x00" as *const u8 as *const libc::c_char) == 0 {
return dc_strdup(DC_VERSION_STR as *const u8 as *const libc::c_char);
} else if strcmp(
key,
b"sys.msgsize_max_recommended\x00" as *const u8 as *const libc::c_char,
) == 0
{
return dc_mprintf(
b"%i\x00" as *const u8 as *const libc::c_char,
24 * 1024 * 1024 / 4 * 3,
);
} else if strcmp(
key,
b"sys.config_keys\x00" as *const u8 as *const libc::c_char,
) == 0
{
return get_config_keys_str();
} else {
return dc_strdup(0 as *const libc::c_char);
}; };
if value.is_some() {
return value.unwrap();
}
match key.as_ref() {
"e2ee_enabled" => "1".into(),
"mdns_enabled" => "1".into(),
"imap_folder" => "INBOX".into(),
"inbox_watch" => "1".into(),
"sentbox_watch" | "mvbox_watch" | "mvbox_move" => "1".into(),
"show_emails" => "0".into(),
"selfstatus" => {
let s = unsafe { dc_stock_str(context, 13) };
let res = to_string(s);
unsafe { free(s as *mut _) };
res
}
_ => "".into(),
}
} }
unsafe fn get_config_keys_str() -> *mut libc::c_char { fn is_gettable_config_key(key: impl AsRef<str>) -> bool {
let mut ret = String::new(); SYS_CONFIG_KEYS
let mut i = 0; .into_iter()
while i .find(|c| **c == key.as_ref())
< (::std::mem::size_of::<[*const libc::c_char; 33]>()) .is_some()
.wrapping_div(::std::mem::size_of::<*mut libc::c_char>()) || is_settable_config_key(key)
{ }
if !ret.is_empty() {
ret += " ";
}
ret += &to_string(config_keys[i as usize]);
i += 1
}
let mut i = 0; fn get_sys_config_str(key: impl AsRef<str>) -> String {
while i match key.as_ref() {
< (::std::mem::size_of::<[*const libc::c_char; 3]>()) "sys.version" => std::str::from_utf8(DC_VERSION_STR).unwrap().into(),
.wrapping_div(::std::mem::size_of::<*mut libc::c_char>()) "sys.msgsize_max_recommended" => format!("{}", 24 * 1024 * 1024 / 4 * 3),
{ "sys.config_keys" => get_config_keys_str(),
if !ret.is_empty() { _ => "".into(),
ret += " ";
}
ret += &to_string(sys_config_keys[i as usize]);
i += 1
} }
}
strdup(to_cstring(ret).as_ptr()) fn get_config_keys_str() -> String {
let keys = &CONFIG_KEYS[..].join(" ");
let sys_keys = &SYS_CONFIG_KEYS[..].join(" ");
format!(" {} {} ", keys, sys_keys)
} }
pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char { pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
let unset = "0"; let unset = "0";
let l = dc_loginparam_new(); let l = dc_loginparam_read(context, &context.sql, "");
let l2 = dc_loginparam_new(); let l2 = dc_loginparam_read(context, &context.sql, "configured_");
dc_loginparam_read( let displayname = sql::get_config(context, &context.sql, "displayname", None);
context,
l,
&context.sql,
b"\x00" as *const u8 as *const libc::c_char,
);
dc_loginparam_read(
context,
l2,
&context.sql,
b"configured_\x00" as *const u8 as *const libc::c_char,
);
let displayname = dc_sqlite3_get_config(
context,
&context.sql,
b"displayname\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
let chats = dc_get_chat_cnt(context) as usize; let chats = dc_get_chat_cnt(context) as usize;
let real_msgs = dc_get_real_msg_cnt(context) as usize; let real_msgs = dc_get_real_msg_cnt(context) as usize;
let deaddrop_msgs = dc_get_deaddrop_msg_cnt(context) as usize; let deaddrop_msgs = dc_get_deaddrop_msg_cnt(context) as usize;
let contacts = dc_get_real_contact_cnt(context) as usize; let contacts = dc_get_real_contact_cnt(context) as usize;
let is_configured = dc_sqlite3_get_config_int( let is_configured = sql::get_config_int(context, &context.sql, "configured", 0);
let dbversion = sql::get_config_int(context, &context.sql, "dbversion", 0);
let e2ee_enabled = sql::get_config_int(context, &context.sql, "e2ee_enabled", 1);
let mdns_enabled = sql::get_config_int(context, &context.sql, "mdns_enabled", 1);
let prv_key_cnt: Option<isize> = sql::query_row(
context, context,
&context.sql, &context.sql,
b"configured\x00" as *const u8 as *const libc::c_char, "SELECT COUNT(*) FROM keypairs;",
rusqlite::NO_PARAMS,
0, 0,
); );
let dbversion = dc_sqlite3_get_config_int(
let pub_key_cnt: Option<isize> = sql::query_row(
context, context,
&context.sql, &context.sql,
b"dbversion\x00" as *const u8 as *const libc::c_char, "SELECT COUNT(*) FROM acpeerstates;",
rusqlite::NO_PARAMS,
0, 0,
); );
let e2ee_enabled = dc_sqlite3_get_config_int(
context, let fingerprint_str = if let Some(key) = Key::from_self_public(context, &l2.addr, &context.sql)
&context.sql, {
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1,
);
let mdns_enabled = dc_sqlite3_get_config_int(
context,
&context.sql,
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1,
);
let mut stmt = dc_sqlite3_prepare(
context,
&context.sql,
b"SELECT COUNT(*) FROM keypairs;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
let prv_key_cnt = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
stmt = dc_sqlite3_prepare(
context,
&context.sql,
b"SELECT COUNT(*) FROM acpeerstates;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
let pub_key_cnt = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
let fingerprint_str =
if let Some(key) = Key::from_self_public(context, (*l2).addr, &context.sql) {
key.fingerprint() key.fingerprint()
} else { } else {
"<Not yet calculated>".into() "<Not yet calculated>".into()
}; };
let l_readable_str = dc_loginparam_get_readable(l); let l_readable_str = dc_loginparam_get_readable(&l);
let l2_readable_str = dc_loginparam_get_readable(l2); let l2_readable_str = dc_loginparam_get_readable(&l2);
let inbox_watch = dc_sqlite3_get_config_int( let inbox_watch = sql::get_config_int(context, &context.sql, "inbox_watch", 1);
let sentbox_watch = sql::get_config_int(context, &context.sql, "sentbox_watch", 1);
let mvbox_watch = sql::get_config_int(context, &context.sql, "mvbox_watch", 1);
let mvbox_move = sql::get_config_int(context, &context.sql, "mvbox_move", 1);
let folders_configured = sql::get_config_int(context, &context.sql, "folders_configured", 0);
let configured_sentbox_folder = sql::get_config(
context, context,
&context.sql, &context.sql,
b"inbox_watch\x00" as *const u8 as *const libc::c_char, "configured_sentbox_folder",
1, Some("<unset>"),
); );
let sentbox_watch = dc_sqlite3_get_config_int( let configured_mvbox_folder = sql::get_config(
context, context,
&context.sql, &context.sql,
b"sentbox_watch\x00" as *const u8 as *const libc::c_char, "configured_mvbox_folder",
1, Some("<unset>"),
);
let mvbox_watch = dc_sqlite3_get_config_int(
context,
&context.sql,
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1,
);
let mvbox_move = dc_sqlite3_get_config_int(
context,
&context.sql,
b"mvbox_move\x00" as *const u8 as *const libc::c_char,
1,
);
let folders_configured = dc_sqlite3_get_config_int(
context,
&context.sql,
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0,
);
let configured_sentbox_folder = dc_sqlite3_get_config(
context,
&context.sql,
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
b"<unset>\x00" as *const u8 as *const libc::c_char,
);
let configured_mvbox_folder = dc_sqlite3_get_config(
context,
&context.sql,
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
b"<unset>\x00" as *const u8 as *const libc::c_char,
); );
let res = format!( let res = format!(
@@ -743,7 +628,7 @@ pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
fingerprint={}\n\ fingerprint={}\n\
level=awesome\n", level=awesome\n",
as_str(DC_VERSION_STR as *const u8 as *const _), as_str(DC_VERSION_STR as *const u8 as *const _),
as_str(libsqlite3_sys::SQLITE_VERSION as *const u8 as *const libc::c_char), rusqlite::version(),
sqlite3_threadsafe(), sqlite3_threadsafe(),
// arch // arch
(::std::mem::size_of::<*mut libc::c_void>()).wrapping_mul(8), (::std::mem::size_of::<*mut libc::c_void>()).wrapping_mul(8),
@@ -762,36 +647,24 @@ pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
} else { } else {
unset unset
}, },
if !displayname.is_null() { displayname.unwrap_or_else(|| unset.into()),
as_str(displayname)
} else {
unset
},
is_configured, is_configured,
as_str(l_readable_str), l_readable_str,
as_str(l2_readable_str), l2_readable_str,
inbox_watch, inbox_watch,
sentbox_watch, sentbox_watch,
mvbox_watch, mvbox_watch,
mvbox_move, mvbox_move,
folders_configured, folders_configured,
as_str(configured_sentbox_folder), configured_sentbox_folder.unwrap_or_default(),
as_str(configured_mvbox_folder), configured_mvbox_folder.unwrap_or_default(),
mdns_enabled, mdns_enabled,
e2ee_enabled, e2ee_enabled,
prv_key_cnt, prv_key_cnt.unwrap_or_default(),
pub_key_cnt, pub_key_cnt.unwrap_or_default(),
fingerprint_str, fingerprint_str,
); );
dc_loginparam_unref(l);
dc_loginparam_unref(l2);
free(displayname as *mut libc::c_void);
free(l_readable_str as *mut libc::c_void);
free(l2_readable_str as *mut libc::c_void);
free(configured_sentbox_folder as *mut libc::c_void);
free(configured_mvbox_folder as *mut libc::c_void);
strdup(to_cstring(res).as_ptr()) strdup(to_cstring(res).as_ptr())
} }
@@ -799,155 +672,106 @@ pub unsafe fn dc_get_version_str() -> *mut libc::c_char {
dc_strdup(DC_VERSION_STR as *const u8 as *const libc::c_char) dc_strdup(DC_VERSION_STR as *const u8 as *const libc::c_char)
} }
pub unsafe fn dc_get_fresh_msgs(context: &Context) -> *mut dc_array_t { pub fn dc_get_fresh_msgs(context: &Context) -> *mut dc_array_t {
let show_deaddrop = 0; let show_deaddrop = 0;
let ret = dc_array_new(128 as size_t);
let mut stmt = 0 as *mut sqlite3_stmt; context
if !ret.is_null() { .sql
stmt = dc_sqlite3_prepare( .query_map(
context, "SELECT m.id FROM msgs m LEFT JOIN contacts ct \
&context.sql,
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=? \
AND m.hidden=0 \ AND m.hidden=0 \
AND m.chat_id>? \ AND m.chat_id>? \
AND ct.blocked=0 \ AND ct.blocked=0 \
AND (c.blocked=0 OR c.blocked=?) ORDER BY m.timestamp DESC,m.id DESC;\x00" AND (c.blocked=0 OR c.blocked=?) ORDER BY m.timestamp DESC,m.id DESC;",
as *const u8 as *const libc::c_char, &[10, 9, if 0 != show_deaddrop { 2 } else { 0 }],
); |row| row.get(0),
sqlite3_bind_int(stmt, 1, 10); |rows| {
sqlite3_bind_int(stmt, 2, 9); let ret = unsafe { dc_array_new(128 as size_t) };
sqlite3_bind_int(stmt, 3, if 0 != show_deaddrop { 2 } else { 0 });
while sqlite3_step(stmt) == 100 { for row in rows {
dc_array_add_id(ret, sqlite3_column_int(stmt, 0) as uint32_t); let id = row?;
unsafe { dc_array_add_id(ret, id) };
} }
} Ok(ret)
sqlite3_finalize(stmt); },
ret )
.unwrap()
} }
pub unsafe fn dc_search_msgs( pub fn dc_search_msgs(
context: &Context, context: &Context,
chat_id: uint32_t, chat_id: uint32_t,
query: *const libc::c_char, query: *const libc::c_char,
) -> *mut dc_array_t { ) -> *mut dc_array_t {
let mut success = 0; if query.is_null() {
let ret = dc_array_new(100 as size_t); return std::ptr::null_mut();
let mut strLikeInText = 0 as *mut libc::c_char; }
let mut strLikeBeg = 0 as *mut libc::c_char;
let mut real_query = 0 as *mut libc::c_char;
let mut stmt = 0 as *mut sqlite3_stmt;
if !(ret.is_null() || query.is_null()) { let real_query = to_string(query).trim().to_string();
real_query = dc_strdup(query); if real_query.is_empty() {
dc_trim(real_query); return std::ptr::null_mut();
if *real_query.offset(0isize) as libc::c_int == 0 { }
success = 1 let strLikeInText = format!("%{}%", &real_query);
} else { let strLikeBeg = format!("{}%", &real_query);
strLikeInText = dc_mprintf(
b"%%%s%%\x00" as *const u8 as *const libc::c_char, let query = if 0 != chat_id {
real_query, "SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id WHERE m.chat_id=? \
);
strLikeBeg = dc_mprintf(b"%s%%\x00" as *const u8 as *const libc::c_char, real_query);
if 0 != chat_id {
stmt = dc_sqlite3_prepare(
context,
&context.sql,
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 \
AND ct.blocked=0 AND (txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp,m.id;\x00" AND ct.blocked=0 AND (txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp,m.id;"
as *const u8 as *const libc::c_char
);
sqlite3_bind_int(stmt, 1, chat_id as libc::c_int);
sqlite3_bind_text(stmt, 2, strLikeInText, -1, None);
sqlite3_bind_text(stmt, 3, strLikeBeg, -1, None);
} else { } else {
let show_deaddrop = 0; "SELECT m.id, m.timestamp FROM msgs m LEFT JOIN contacts ct ON m.from_id=ct.id \
stmt = dc_sqlite3_prepare(
context,
&context.sql,
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 \
AND (c.blocked=0 OR c.blocked=?) \ AND (c.blocked=0 OR c.blocked=?) \
AND ct.blocked=0 AND (m.txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp DESC,m.id DESC;\x00" AND ct.blocked=0 AND (m.txt LIKE ? OR ct.name LIKE ?) ORDER BY m.timestamp DESC,m.id DESC;"
as *const u8 as *const libc::c_char };
);
sqlite3_bind_int(stmt, 1, if 0 != show_deaddrop { 2 } else { 0 }); let ret = unsafe { dc_array_new(100 as size_t) };
sqlite3_bind_text(stmt, 2, strLikeInText, -1, None);
sqlite3_bind_text(stmt, 3, strLikeBeg, -1, None); let success = context
} .sql
while sqlite3_step(stmt) == 100 { .query_map(
dc_array_add_id(ret, sqlite3_column_int(stmt, 0) as uint32_t); query,
} params![chat_id as libc::c_int, &strLikeInText, &strLikeBeg],
success = 1 |row| row.get::<_, i32>(0),
|rows| {
for id in rows {
unsafe { dc_array_add_id(ret, id? as u32) };
} }
Ok(())
},
)
.is_ok();
if success {
return ret;
} }
free(strLikeInText as *mut libc::c_void);
free(strLikeBeg as *mut libc::c_void);
free(real_query as *mut libc::c_void);
sqlite3_finalize(stmt);
if 0 != success {
ret
} else {
if !ret.is_null() { if !ret.is_null() {
dc_array_unref(ret); unsafe { dc_array_unref(ret) };
} }
0 as *mut dc_array_t std::ptr::null_mut()
}
pub fn dc_is_inbox(_context: &Context, folder_name: impl AsRef<str>) -> bool {
folder_name.as_ref() == "INBOX"
}
pub fn dc_is_sentbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
let sentbox_name = sql::get_config(context, &context.sql, "configured_sentbox_folder", None);
if let Some(name) = sentbox_name {
name == folder_name.as_ref()
} else {
false
} }
} }
pub unsafe fn dc_is_inbox(_context: &Context, folder_name: *const libc::c_char) -> libc::c_int { pub fn dc_is_mvbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
let mut is_inbox = 0; let mvbox_name = sql::get_config(context, &context.sql, "configured_mvbox_folder", None);
if !folder_name.is_null() {
is_inbox = if strcasecmp(
b"INBOX\x00" as *const u8 as *const libc::c_char,
folder_name,
) == 0
{
1
} else {
0
}
}
is_inbox
}
pub unsafe fn dc_is_sentbox(context: &Context, folder_name: *const libc::c_char) -> libc::c_int { if let Some(name) = mvbox_name {
let sentbox_name = dc_sqlite3_get_config( name == folder_name.as_ref()
context,
&context.sql,
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
let mut is_sentbox = 0;
if !sentbox_name.is_null() && !folder_name.is_null() {
is_sentbox = if strcasecmp(sentbox_name, folder_name) == 0 {
1
} else { } else {
0 false
} }
}
free(sentbox_name as *mut libc::c_void);
is_sentbox
}
pub unsafe fn dc_is_mvbox(context: &Context, folder_name: *const libc::c_char) -> libc::c_int {
let mvbox_name = dc_sqlite3_get_config(
context,
&context.sql,
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
let mut is_mvbox = 0;
if !mvbox_name.is_null() && !folder_name.is_null() {
is_mvbox = if strcasecmp(mvbox_name, folder_name) == 0 {
1
} else {
0
}
}
free(mvbox_name as *mut libc::c_void);
is_mvbox
} }

1836
src/dc_chat.rs
View File

File diff suppressed because it is too large Load Diff

225
src/dc_chatlist.rs
View File

@@ -4,9 +4,9 @@ use crate::dc_chat::*;
use crate::dc_contact::*; use crate::dc_contact::*;
use crate::dc_lot::*; use crate::dc_lot::*;
use crate::dc_msg::*; use crate::dc_msg::*;
use crate::dc_sqlite3::*;
use crate::dc_stock::*; use crate::dc_stock::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -120,17 +120,17 @@ unsafe fn dc_chatlist_load_from_db(
mut chatlist: *mut dc_chatlist_t, mut chatlist: *mut dc_chatlist_t,
listflags: libc::c_int, listflags: libc::c_int,
query__: *const libc::c_char, query__: *const libc::c_char,
query_contact_id: uint32_t, query_contact_id: u32,
) -> libc::c_int { ) -> libc::c_int {
let current_block: u64;
//clock_t start = clock(); //clock_t start = clock();
let mut success: libc::c_int = 0i32;
let mut add_archived_link_item: libc::c_int = 0i32; if chatlist.is_null() || (*chatlist).magic != 0xc4a71157u32 {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; return 0;
let mut strLikeCmd: *mut libc::c_char = 0 as *mut libc::c_char; }
let mut query: *mut libc::c_char = 0 as *mut libc::c_char;
if !(chatlist.is_null() || (*chatlist).magic != 0xc4a71157u32) {
dc_chatlist_empty(chatlist); dc_chatlist_empty(chatlist);
let mut add_archived_link_item = 0;
// select with left join and minimum: // select with left join and minimum:
// - the inner select must use `hidden` and _not_ `m.hidden` // - the inner select must use `hidden` and _not_ `m.hidden`
// which would refer the outer select and take a lot of time // which would refer the outer select and take a lot of time
@@ -141,125 +141,132 @@ unsafe fn dc_chatlist_load_from_db(
// (otherwise it would be hard to follow conversations, wa and tg do the same) // (otherwise it would be hard to follow conversations, wa and tg do the same)
// for the deaddrop, however, they should really be hidden, however, _currently_ the deaddrop is not // for the deaddrop, however, they should really be hidden, however, _currently_ the deaddrop is not
// shown at all permanent in the chatlist. // shown at all permanent in the chatlist.
if 0 != query_contact_id {
stmt = let process_fn = |row: &rusqlite::Row| {
dc_sqlite3_prepare( dc_array_add_id((*chatlist).chatNlastmsg_ids, row.get(0)?);
(*chatlist).context, dc_array_add_id((*chatlist).chatNlastmsg_ids, row.get(1)?);
&(*chatlist).context.sql, Ok(())
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
); let success =
sqlite3_bind_int(stmt, 1i32, query_contact_id as libc::c_int); if query_contact_id != 0 {
current_block = 3437258052017859086; (*chatlist).context.sql.query_map(
} else if 0 != listflags & 0x1i32 { "SELECT c.id, m.id FROM chats c LEFT JOIN msgs m \
stmt = ON c.id=m.chat_id \
dc_sqlite3_prepare( AND m.timestamp=( SELECT MAX(timestamp) \
(*chatlist).context, FROM msgs WHERE chat_id=c.id \
&(*chatlist).context.sql, AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 \
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" AND c.blocked=0 AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?) \
as *const u8 as *const libc::c_char); GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;",
current_block = 3437258052017859086; params![query_contact_id as i32],
process_fn,
|res| res.collect::<rusqlite::Result<Vec<_>>>().map_err(Into::into),
)
} else if 0 != listflags & 0x1 {
(*chatlist).context.sql.query_map(
"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;",
params![],
process_fn,
|res| {
res.collect::<rusqlite::Result<Vec<_>>>()
.map_err(Into::into)
},
)
} else if query__.is_null() { } else if query__.is_null() {
if 0 == listflags & 0x2i32 { if 0 == listflags & 0x2 {
let last_deaddrop_fresh_msg_id: uint32_t = let last_deaddrop_fresh_msg_id = get_last_deaddrop_fresh_msg((*chatlist).context);
get_last_deaddrop_fresh_msg((*chatlist).context); if last_deaddrop_fresh_msg_id > 0 {
if last_deaddrop_fresh_msg_id > 0i32 as libc::c_uint { dc_array_add_id((*chatlist).chatNlastmsg_ids, 1);
dc_array_add_id((*chatlist).chatNlastmsg_ids, 1i32 as uint32_t);
dc_array_add_id((*chatlist).chatNlastmsg_ids, last_deaddrop_fresh_msg_id); dc_array_add_id((*chatlist).chatNlastmsg_ids, last_deaddrop_fresh_msg_id);
} }
add_archived_link_item = 1i32 add_archived_link_item = 1;
} }
stmt = (*chatlist).context.sql.query_map(
dc_sqlite3_prepare( "SELECT c.id, m.id FROM chats c \
(*chatlist).context, LEFT JOIN msgs m \
&(*chatlist).context.sql, ON c.id=m.chat_id \
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" AND m.timestamp=( SELECT MAX(timestamp) \
as *const u8 as *const libc::c_char); FROM msgs WHERE chat_id=c.id \
current_block = 3437258052017859086; 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;",
params![],
process_fn,
|res| {
res.collect::<rusqlite::Result<Vec<_>>>()
.map_err(Into::into)
},
)
} else { } else {
query = dc_strdup(query__); let query = to_string(query__).trim().to_string();
dc_trim(query); if query.is_empty() {
if *query.offset(0isize) as libc::c_int == 0i32 { return 1;
success = 1i32;
current_block = 15179736777190528364;
} else { } else {
strLikeCmd = dc_mprintf(b"%%%s%%\x00" as *const u8 as *const libc::c_char, query); let strLikeCmd = format!("%{}%", query);
stmt = (*chatlist).context.sql.query_map(
dc_sqlite3_prepare( "SELECT c.id, m.id FROM chats c LEFT JOIN msgs m \
(*chatlist).context, ON c.id=m.chat_id \
&(*chatlist).context.sql, AND m.timestamp=( SELECT MAX(timestamp) \
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" FROM msgs WHERE chat_id=c.id \
as *const u8 as AND (hidden=0 OR (hidden=1 AND state=19))) WHERE c.id>9 \
*const libc::c_char); AND c.blocked=0 AND c.name LIKE ? \
sqlite3_bind_text(stmt, 1i32, strLikeCmd, -1i32, None); GROUP BY c.id ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;",
current_block = 3437258052017859086; params![strLikeCmd],
process_fn,
|res| {
res.collect::<rusqlite::Result<Vec<_>>>()
.map_err(Into::into)
},
)
} }
};
if 0 != add_archived_link_item && dc_get_archived_cnt((*chatlist).context) > 0 {
if dc_array_get_cnt((*chatlist).chatNlastmsg_ids) == 0 && 0 != listflags & 0x4 {
dc_array_add_id((*chatlist).chatNlastmsg_ids, 7 as uint32_t);
dc_array_add_id((*chatlist).chatNlastmsg_ids, 0 as uint32_t);
} }
match current_block { dc_array_add_id((*chatlist).chatNlastmsg_ids, 6 as uint32_t);
15179736777190528364 => {} dc_array_add_id((*chatlist).chatNlastmsg_ids, 0 as uint32_t);
_ => {
while sqlite3_step(stmt) == 100i32 {
dc_array_add_id(
(*chatlist).chatNlastmsg_ids,
sqlite3_column_int(stmt, 0i32) as uint32_t,
);
dc_array_add_id(
(*chatlist).chatNlastmsg_ids,
sqlite3_column_int(stmt, 1i32) as uint32_t,
);
}
if 0 != add_archived_link_item && dc_get_archived_cnt((*chatlist).context) > 0i32 {
if dc_array_get_cnt((*chatlist).chatNlastmsg_ids) == 0
&& 0 != listflags & 0x4i32
{
dc_array_add_id((*chatlist).chatNlastmsg_ids, 7i32 as uint32_t);
dc_array_add_id((*chatlist).chatNlastmsg_ids, 0i32 as uint32_t);
}
dc_array_add_id((*chatlist).chatNlastmsg_ids, 6i32 as uint32_t);
dc_array_add_id((*chatlist).chatNlastmsg_ids, 0i32 as uint32_t);
} }
(*chatlist).cnt = dc_array_get_cnt((*chatlist).chatNlastmsg_ids).wrapping_div(2); (*chatlist).cnt = dc_array_get_cnt((*chatlist).chatNlastmsg_ids).wrapping_div(2);
success = 1i32
} success.is_ok() as libc::c_int
}
}
sqlite3_finalize(stmt);
free(query as *mut libc::c_void);
free(strLikeCmd as *mut libc::c_void);
success
} }
// Context functions to work with chatlist // Context functions to work with chatlist
pub unsafe fn dc_get_archived_cnt(context: &Context) -> libc::c_int { pub fn dc_get_archived_cnt(context: &Context) -> libc::c_int {
let mut ret: libc::c_int = 0i32; sql::query_row(
let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare(
context, context,
&context.sql, &context.sql,
b"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;\x00" as *const u8 "SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;",
as *const libc::c_char, params![],
); 0,
if sqlite3_step(stmt) == 100i32 { )
ret = sqlite3_column_int(stmt, 0i32) .unwrap_or_default()
}
sqlite3_finalize(stmt);
ret
} }
unsafe fn get_last_deaddrop_fresh_msg(context: &Context) -> uint32_t { fn get_last_deaddrop_fresh_msg(context: &Context) -> u32 {
let mut ret: uint32_t = 0i32 as uint32_t; // we have an index over the state-column, this should be sufficient as there are typically only few fresh messages
let stmt: *mut sqlite3_stmt; sql::query_row(
stmt =
dc_sqlite3_prepare(
context, context,
&context.sql, &context.sql,
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" "SELECT m.id FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \
as *const u8 as *const libc::c_char); WHERE m.state=10 \
/* we have an index over the state-column, this should be sufficient as there are typically only few fresh messages */ AND m.hidden=0 \
if !(sqlite3_step(stmt) != 100i32) { AND c.blocked=2 \
ret = sqlite3_column_int(stmt, 0i32) as uint32_t ORDER BY m.timestamp DESC, m.id DESC;",
} params![],
sqlite3_finalize(stmt); 0,
ret )
.unwrap_or_default()
} }
pub unsafe fn dc_chatlist_get_cnt(chatlist: *const dc_chatlist_t) -> size_t { pub unsafe fn dc_chatlist_get_cnt(chatlist: *const dc_chatlist_t) -> size_t {

1413
src/dc_configure.rs
View File

File diff suppressed because it is too large Load Diff

935
src/dc_contact.rs
View File

File diff suppressed because it is too large Load Diff

132
src/dc_e2ee.rs
View File

@@ -17,15 +17,14 @@ use mmime::{mailmime_substitute, MAILIMF_NO_ERROR, MAIL_NO_ERROR};
use crate::aheader::*; use crate::aheader::*;
use crate::context::Context; use crate::context::Context;
use crate::dc_log::*;
use crate::dc_mimeparser::*; use crate::dc_mimeparser::*;
use crate::dc_securejoin::*; use crate::dc_securejoin::*;
use crate::dc_sqlite3::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::key::*; use crate::key::*;
use crate::keyring::*; use crate::keyring::*;
use crate::peerstate::*; use crate::peerstate::*;
use crate::pgp::*; use crate::pgp::*;
use crate::sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -82,28 +81,17 @@ pub unsafe fn dc_e2ee_encrypt(
|| plain.is_null()) || plain.is_null())
{ {
/* 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. */
let prefer_encrypt = if 0 let prefer_encrypt = if 0 != sql::get_config_int(context, &context.sql, "e2ee_enabled", 1) {
!= dc_sqlite3_get_config_int(
context,
&context.sql,
b"e2ee_enabled\x00" as *const u8 as *const libc::c_char,
1,
) {
EncryptPreference::Mutual EncryptPreference::Mutual
} else { } else {
EncryptPreference::NoPreference EncryptPreference::NoPreference
}; };
let addr = dc_sqlite3_get_config( let addr = sql::get_config(context, &context.sql, "configured_addr", None);
context,
&context.sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if !addr.is_null() { if let Some(addr) = addr {
if let Some(public_key) = if let Some(public_key) =
load_or_generate_self_public_key(context, addr, in_out_message) load_or_generate_self_public_key(context, &addr, in_out_message)
{ {
/*only for random-seed*/ /*only for random-seed*/
if prefer_encrypt == EncryptPreference::Mutual || 0 != e2ee_guaranteed { if prefer_encrypt == EncryptPreference::Mutual || 0 != e2ee_guaranteed {
@@ -111,15 +99,10 @@ pub unsafe fn dc_e2ee_encrypt(
let mut iter1: *mut clistiter; let mut iter1: *mut clistiter;
iter1 = (*recipients_addr).first; iter1 = (*recipients_addr).first;
while !iter1.is_null() { while !iter1.is_null() {
let recipient_addr: *const libc::c_char = (if !iter1.is_null() { let recipient_addr = to_string((*iter1).data as *const libc::c_char);
(*iter1).data if recipient_addr != addr {
} else {
0 as *mut libc::c_void
})
as *const libc::c_char;
if strcasecmp(recipient_addr, addr) != 0 {
let peerstate = let peerstate =
Peerstate::from_addr(context, &context.sql, as_str(recipient_addr)); Peerstate::from_addr(context, &context.sql, &recipient_addr);
if peerstate.is_some() if peerstate.is_some()
&& (peerstate.as_ref().unwrap().prefer_encrypt && (peerstate.as_ref().unwrap().prefer_encrypt
== EncryptPreference::Mutual == EncryptPreference::Mutual
@@ -145,7 +128,7 @@ pub unsafe fn dc_e2ee_encrypt(
} }
let sign_key = if 0 != do_encrypt { let sign_key = if 0 != do_encrypt {
keyring.add_ref(&public_key); keyring.add_ref(&public_key);
let key = Key::from_self_private(context, addr, &context.sql); let key = Key::from_self_private(context, addr.clone(), &context.sql);
if key.is_none() { if key.is_none() {
do_encrypt = 0i32; do_encrypt = 0i32;
@@ -366,8 +349,7 @@ pub unsafe fn dc_e2ee_encrypt(
match current_block { match current_block {
14181132614457621749 => {} 14181132614457621749 => {}
_ => { _ => {
let addr = CStr::from_ptr(addr).to_str().unwrap(); let aheader = Aheader::new(addr, public_key, prefer_encrypt);
let aheader = Aheader::new(addr.into(), public_key, prefer_encrypt);
let rendered = CString::new(aheader.to_string()).unwrap(); let rendered = CString::new(aheader.to_string()).unwrap();
mailimf_fields_add( mailimf_fields_add(
@@ -503,13 +485,13 @@ unsafe fn new_data_part(
******************************************************************************/ ******************************************************************************/
unsafe fn load_or_generate_self_public_key( unsafe fn load_or_generate_self_public_key(
context: &Context, context: &Context,
self_addr: *const libc::c_char, self_addr: impl AsRef<str>,
_random_data_mime: *mut mailmime, _random_data_mime: *mut mailmime,
) -> Option<Key> { ) -> Option<Key> {
/* avoid double creation (we unlock the database during creation) */ /* avoid double creation (we unlock the database during creation) */
static mut s_in_key_creation: libc::c_int = 0i32; static mut s_in_key_creation: libc::c_int = 0;
let mut key = Key::from_self_public(context, self_addr, &context.sql); let mut key = Key::from_self_public(context, &self_addr, &context.sql);
if key.is_some() { if key.is_some() {
return key; return key;
} }
@@ -521,46 +503,35 @@ unsafe fn load_or_generate_self_public_key(
let key_creation_here = 1; let key_creation_here = 1;
s_in_key_creation = 1; s_in_key_creation = 1;
let start: libc::clock_t = clock(); let start = clock();
dc_log_info( info!(
context, context,
0i32, 0, "Generating keypair with {} bits, e={} ...", 2048, 65537,
b"Generating keypair with %i bits, e=%i ...\x00" as *const u8 as *const libc::c_char,
2048i32,
65537i32,
); );
if let Some((public_key, private_key)) = dc_pgp_create_keypair(self_addr) { if let Some((public_key, private_key)) = dc_pgp_create_keypair(&self_addr) {
if !dc_key_save_self_keypair( if !dc_key_save_self_keypair(
context, context,
&public_key, &public_key,
&private_key, &private_key,
self_addr, &self_addr,
1i32, 1i32,
&context.sql, &context.sql,
) { ) {
/*set default*/ /*set default*/
dc_log_warning( warn!(context, 0, "Cannot save keypair.",);
context,
0i32,
b"Cannot save keypair.\x00" as *const u8 as *const libc::c_char,
);
} else { } else {
dc_log_info( info!(
context, context,
0i32, 0,
b"Keypair generated in %.3f s.\x00" as *const u8 as *const libc::c_char, "Keypair generated in {:.3}s.",
clock().wrapping_sub(start) as libc::c_double / 1000000i32 as libc::c_double, clock().wrapping_sub(start) as libc::c_double / 1000000 as libc::c_double,
); );
} }
key = Some(public_key); key = Some(public_key);
} else { } else {
dc_log_warning( warn!(context, 0, "Cannot create keypair.");
context,
0i32,
b"Cannot create keypair.\x00" as *const u8 as *const libc::c_char,
);
} }
if 0 != key_creation_here { if 0 != key_creation_here {
@@ -583,7 +554,6 @@ pub unsafe fn dc_e2ee_decrypt(
let imffields: *mut mailimf_fields = mailmime_find_mailimf_fields(in_out_message); let imffields: *mut mailimf_fields = mailmime_find_mailimf_fields(in_out_message);
let mut message_time = 0; let mut message_time = 0;
let mut from: *mut libc::c_char = 0 as *mut libc::c_char; let mut from: *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 private_keyring = Keyring::default(); let mut private_keyring = Keyring::default();
let mut public_keyring_for_validate = Keyring::default(); let mut public_keyring_for_validate = Keyring::default();
let mut gossip_headers: *mut mailimf_fields = 0 as *mut mailimf_fields; let mut gossip_headers: *mut mailimf_fields = 0 as *mut mailimf_fields;
@@ -612,28 +582,23 @@ pub unsafe fn dc_e2ee_decrypt(
if let Some(ref mut peerstate) = peerstate { if let Some(ref mut peerstate) = peerstate {
if let Some(ref header) = autocryptheader { if let Some(ref header) = autocryptheader {
peerstate.apply_header(&header, message_time as u64); peerstate.apply_header(&header, message_time);
peerstate.save_to_db(&context.sql, false); peerstate.save_to_db(&context.sql, false);
} else if message_time as u64 > peerstate.last_seen_autocrypt } else if message_time > peerstate.last_seen_autocrypt
&& 0 == contains_report(in_out_message) && 0 == contains_report(in_out_message)
{ {
peerstate.degrade_encryption(message_time as u64); peerstate.degrade_encryption(message_time);
peerstate.save_to_db(&context.sql, false); peerstate.save_to_db(&context.sql, false);
} }
} else if let Some(ref header) = autocryptheader { } else if let Some(ref header) = autocryptheader {
let p = Peerstate::from_header(context, header, message_time as u64); let p = Peerstate::from_header(context, header, message_time);
p.save_to_db(&context.sql, true); p.save_to_db(&context.sql, true);
peerstate = Some(p); peerstate = Some(p);
} }
} }
/* load private key for decryption */ /* load private key for decryption */
self_addr = dc_sqlite3_get_config( let self_addr = sql::get_config(context, &context.sql, "configured_addr", None);
context, if let Some(self_addr) = self_addr {
&context.sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if !self_addr.is_null() {
if private_keyring.load_self_private_for_decrypting(context, self_addr, &context.sql) { if private_keyring.load_self_private_for_decrypting(context, self_addr, &context.sql) {
if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 { if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 {
peerstate = Peerstate::from_addr(&context, &context.sql, as_str(from)); peerstate = Peerstate::from_addr(&context, &context.sql, as_str(from));
@@ -681,7 +646,6 @@ pub unsafe fn dc_e2ee_decrypt(
} }
free(from as *mut libc::c_void); free(from as *mut libc::c_void);
free(self_addr as *mut libc::c_void);
} }
unsafe fn update_gossip_peerstates( unsafe fn update_gossip_peerstates(
@@ -722,10 +686,10 @@ unsafe fn update_gossip_peerstates(
let mut peerstate = let mut peerstate =
Peerstate::from_addr(context, &context.sql, &header.addr); Peerstate::from_addr(context, &context.sql, &header.addr);
if let Some(ref mut peerstate) = peerstate { if let Some(ref mut peerstate) = peerstate {
peerstate.apply_gossip(header, message_time as u64); peerstate.apply_gossip(header, message_time);
peerstate.save_to_db(&context.sql, false); peerstate.save_to_db(&context.sql, false);
} else { } else {
let p = Peerstate::from_gossip(context, header, message_time as u64); let p = Peerstate::from_gossip(context, header, message_time);
p.save_to_db(&context.sql, true); p.save_to_db(&context.sql, true);
peerstate = Some(p); peerstate = Some(p);
} }
@@ -737,12 +701,11 @@ unsafe fn update_gossip_peerstates(
gossipped_addr.insert(header.addr.clone()); gossipped_addr.insert(header.addr.clone());
} else { } else {
dc_log_info( info!(
context, context,
0i32, 0,
b"Ignoring gossipped \"%s\" as the address is not in To/Cc list.\x00" "Ignoring gossipped \"{}\" as the address is not in To/Cc list.",
as *const u8 as *const libc::c_char, &header.addr,
CString::new(header.addr.clone()).unwrap().as_ptr(),
); );
} }
} }
@@ -1103,25 +1066,18 @@ pub unsafe fn dc_ensure_secret_key_exists(context: &Context) -> libc::c_int {
(this is to gain some extra-random-seed by the message content and the timespan between program start and message sending) */ (this is to gain some extra-random-seed by the message content and the timespan between program start and message sending) */
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
let self_addr = dc_sqlite3_get_config( let self_addr = sql::get_config(context, &context.sql, "configured_addr", None);
if self_addr.is_none() {
warn!(
context, context,
&context.sql, 0, "Cannot ensure secret key if context is not configured.",
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
); );
if self_addr.is_null() { } else if load_or_generate_self_public_key(context, self_addr.unwrap(), 0 as *mut mailmime)
dc_log_warning( .is_some()
context, {
0i32,
b"Cannot ensure secret key if context is not configured.\x00" as *const u8
as *const libc::c_char,
);
} else if load_or_generate_self_public_key(context, self_addr, 0 as *mut mailmime).is_some() {
/*no random text data for seeding available*/ /*no random text data for seeding available*/
success = 1i32 success = 1;
} }
free(self_addr as *mut libc::c_void);
success success
} }

700
src/dc_imex.rs
View File

File diff suppressed because it is too large Load Diff

593
src/dc_job.rs
View File

@@ -12,15 +12,14 @@ use crate::dc_configure::*;
use crate::dc_imex::*; use crate::dc_imex::*;
use crate::dc_jobthread::*; use crate::dc_jobthread::*;
use crate::dc_location::*; use crate::dc_location::*;
use crate::dc_log::*;
use crate::dc_loginparam::*; use crate::dc_loginparam::*;
use crate::dc_mimefactory::*; use crate::dc_mimefactory::*;
use crate::dc_msg::*; use crate::dc_msg::*;
use crate::dc_param::*; use crate::dc_param::*;
use crate::dc_sqlite3::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::imap::*; use crate::imap::*;
use crate::keyhistory::*; use crate::keyhistory::*;
use crate::sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -59,75 +58,69 @@ pub unsafe fn dc_perform_imap_jobs(context: &Context) {
info!(context, 0, "dc_perform_imap_jobs ended.",); info!(context, 0, "dc_perform_imap_jobs ended.",);
} }
unsafe fn dc_job_perform(context: &Context, thread: libc::c_int, probe_network: libc::c_int) { unsafe fn dc_job_perform(context: &Context, thread: libc::c_int, probe_network: libc::c_int) {
// info!(context, 0, "dc_job_perform {} {}", thread, probe_network); let process_row = |row: &rusqlite::Row| {
let mut select_stmt: *mut sqlite3_stmt; let job = dc_job_t {
let mut job = dc_job_t { job_id: row.get(0)?,
job_id: 0, action: row.get(1)?,
action: 0, foreign_id: row.get(2)?,
foreign_id: 0, desired_timestamp: row.get(5)?,
desired_timestamp: 0, added_timestamp: row.get(4)?,
added_timestamp: 0, tries: row.get(6)?,
tries: 0, param: dc_param_new(),
param: 0 as *mut dc_param_t,
try_again: 0, try_again: 0,
pending_error: 0 as *mut libc::c_char, pending_error: 0 as *mut libc::c_char,
}; };
job.param = dc_param_new();
if probe_network == 0i32 { let packed: String = row.get(3)?;
select_stmt = dc_param_set_packed(job.param, to_cstring(packed).as_ptr());
dc_sqlite3_prepare( Ok(job)
context, };
&context.sql,
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" let query = if probe_network == 0 {
as *const u8 as *const libc::c_char); "SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries \
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64); FROM jobs WHERE thread=? AND desired_timestamp<=? ORDER BY action DESC, added_timestamp;"
sqlite3_bind_int64(select_stmt, 2i32, time() as sqlite3_int64);
} else { } else {
select_stmt = "SELECT id, action, foreign_id, param, added_timestamp, desired_timestamp, tries \
dc_sqlite3_prepare( FROM jobs WHERE thread=? AND tries>0 ORDER BY desired_timestamp, action DESC;"
context, };
&context.sql,
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" let params_no_probe = params![thread as i64, time()];
as *const u8 as *const libc::c_char); let params_probe = params![thread as i64];
sqlite3_bind_int64(select_stmt, 1i32, thread as sqlite3_int64); let params: &[&dyn rusqlite::ToSql] = if probe_network == 0 {
} params_no_probe
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 i64;
job.desired_timestamp = sqlite3_column_int64(select_stmt, 5i32) as i64;
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 { } else {
b"SMTP\x00" as *const u8 as *const libc::c_char params_probe
}, };
job.job_id as libc::c_int,
job.action as libc::c_int, let jobs: Vec<dc_job_t> = context
.sql
.query_map(query, params, process_row, |jobs| {
jobs.collect::<Result<Vec<dc_job_t>, _>>()
.map_err(Into::into)
})
.unwrap_or_default();
for mut job in jobs {
info!(
context,
0,
"{}-job #{}, action {} started...",
if thread == 100 { "INBOX" } else { "SMTP" },
job.job_id,
job.action,
); );
if 900i32 == job.action || 910i32 == job.action {
if 900 == job.action || 910 == job.action {
dc_job_kill_action(context, job.action); dc_job_kill_action(context, job.action);
sqlite3_finalize(select_stmt);
select_stmt = 0 as *mut sqlite3_stmt;
dc_jobthread_suspend(context, &context.sentbox_thread.clone().read().unwrap(), 1); dc_jobthread_suspend(context, &context.sentbox_thread.clone().read().unwrap(), 1);
dc_jobthread_suspend(context, &context.mvbox_thread.clone().read().unwrap(), 1); dc_jobthread_suspend(context, &context.mvbox_thread.clone().read().unwrap(), 1);
dc_suspend_smtp_thread(context, 1i32); dc_suspend_smtp_thread(context, 1);
} }
let mut tries: libc::c_int = 0i32; let mut tries = 0;
while tries <= 1i32 { while tries <= 1 {
job.try_again = 0i32; job.try_again = 0;
// info!(context, 0, "dc_job_perform action {}", job.action);
match job.action { match job.action {
5901 => { 5901 => {
dc_job_do_DC_JOB_SEND(context, &mut job); dc_job_do_DC_JOB_SEND(context, &mut job);
@@ -160,16 +153,16 @@ unsafe fn dc_job_perform(context: &Context, thread: libc::c_int, probe_network:
dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context, &mut job); dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context, &mut job);
} }
105 => { 105 => {
dc_housekeeping(context); sql::housekeeping(context);
} }
_ => {} _ => {}
} }
if job.try_again != -1i32 { if job.try_again != -1 {
break; break;
} }
tries += 1 tries += 1
} }
if 900i32 == job.action || 910i32 == job.action { if 900 == job.action || 910 == job.action {
dc_jobthread_suspend( dc_jobthread_suspend(
context, context,
&mut context.sentbox_thread.clone().read().unwrap(), &mut context.sentbox_thread.clone().read().unwrap(),
@@ -180,57 +173,49 @@ unsafe fn dc_job_perform(context: &Context, thread: libc::c_int, probe_network:
&mut context.mvbox_thread.clone().read().unwrap(), &mut context.mvbox_thread.clone().read().unwrap(),
0, 0,
); );
dc_suspend_smtp_thread(context, 0i32); dc_suspend_smtp_thread(context, 0);
break; break;
} else if job.try_again == 2i32 { } else if job.try_again == 2 {
dc_log_info( info!(
context, context,
0i32, 0,
b"%s-job #%i not yet ready and will be delayed.\x00" as *const u8 "{}-job #{} not yet ready and will be delayed.",
as *const libc::c_char, if thread == 100 { "INBOX" } else { "SMTP" },
if thread == 100i32 { job.job_id
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 { } else if job.try_again == -1 || job.try_again == 3 {
let tries_0: libc::c_int = job.tries + 1i32; let tries = job.tries + 1;
if tries_0 < 17i32 { if tries < 17 {
job.tries = tries_0; job.tries = tries;
let time_offset = get_backoff_time_offset(tries_0); let time_offset = get_backoff_time_offset(tries);
job.desired_timestamp = job.added_timestamp + time_offset; job.desired_timestamp = job.added_timestamp + time_offset;
dc_job_update(context, &mut job); dc_job_update(context, &mut job);
dc_log_info(context, 0i32, info!(
b"%s-job #%i not succeeded on try #%i, retry in ADD_TIME+%i (in %i seconds).\x00" context,
as *const u8 as *const libc::c_char, 0,
if thread == 100i32 { "{}-job #{} not succeeded on try #{}, retry in ADD_TIME+{} (in {} seconds).",
b"INBOX\x00" as *const u8 as if thread == 100 { "INBOX" } else { "SMTP" },
*const libc::c_char job.job_id as libc::c_int,
} else { tries,
b"SMTP\x00" as *const u8 as
*const libc::c_char
}, job.job_id as libc::c_int, tries_0,
time_offset, time_offset,
job.added_timestamp + time_offset - job.added_timestamp + time_offset - time()
time()); );
if thread == 5000i32 && tries_0 < 17i32 - 1i32 { if thread == 5000 && tries < 17 - 1 {
context context
.smtp_state .smtp_state
.clone() .clone()
.0 .0
.lock() .lock()
.unwrap() .unwrap()
.perform_jobs_needed = 2i32; .perform_jobs_needed = 2;
} }
} else { } else {
if job.action == 5901i32 { if job.action == 5901 {
dc_set_msg_failed(context, job.foreign_id, job.pending_error); dc_set_msg_failed(context, job.foreign_id, job.pending_error);
} }
dc_job_delete(context, &mut job); dc_job_delete(context, &mut job);
} }
if !(0 != probe_network) { if 0 == probe_network {
continue; continue;
} }
// on dc_maybe_network() we stop trying here; // on dc_maybe_network() we stop trying here;
@@ -241,21 +226,16 @@ unsafe fn dc_job_perform(context: &Context, thread: libc::c_int, probe_network:
} else { } else {
dc_job_delete(context, &mut job); dc_job_delete(context, &mut job);
} }
}
dc_param_unref(job.param); dc_param_unref(job.param);
free(job.pending_error as *mut libc::c_void); free(job.pending_error as *mut libc::c_void);
sqlite3_finalize(select_stmt); }
} }
unsafe fn dc_job_delete(context: &Context, job: &dc_job_t) { fn dc_job_delete(context: &Context, job: &dc_job_t) -> bool {
let delete_stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( context
context, .sql
&context.sql, .execute("DELETE FROM jobs WHERE id=?;", params![job.job_id as i32])
b"DELETE FROM jobs WHERE id=?;\x00" as *const u8 as *const libc::c_char, .is_ok()
);
sqlite3_bind_int(delete_stmt, 1i32, job.job_id as libc::c_int);
sqlite3_step(delete_stmt);
sqlite3_finalize(delete_stmt);
} }
/* ****************************************************************************** /* ******************************************************************************
@@ -274,20 +254,20 @@ unsafe fn get_backoff_time_offset(c_tries: libc::c_int) -> i64 {
seconds as i64 seconds as i64
} }
unsafe fn dc_job_update(context: &Context, job: &dc_job_t) { fn dc_job_update(context: &Context, job: &dc_job_t) -> bool {
let stmt: *mut sqlite3_stmt = dc_sqlite3_prepare( sql::execute(
context, context,
&context.sql, &context.sql,
b"UPDATE jobs SET desired_timestamp=?, tries=?, param=? WHERE id=?;\x00" as *const u8 "UPDATE jobs SET desired_timestamp=?, tries=?, param=? WHERE id=?;",
as *const libc::c_char, params![
); job.desired_timestamp,
sqlite3_bind_int64(stmt, 1i32, job.desired_timestamp as sqlite3_int64); job.tries as i64,
sqlite3_bind_int64(stmt, 2i32, job.tries as sqlite3_int64); as_str(unsafe { (*job.param).packed }),
sqlite3_bind_text(stmt, 3i32, (*job.param).packed, -1i32, None); job.job_id as i32,
sqlite3_bind_int(stmt, 4i32, job.job_id as libc::c_int); ],
sqlite3_step(stmt); )
sqlite3_finalize(stmt);
} }
unsafe fn dc_suspend_smtp_thread(context: &Context, suspend: libc::c_int) { unsafe fn dc_suspend_smtp_thread(context: &Context, suspend: libc::c_int) {
context.smtp_state.0.lock().unwrap().suspended = suspend; context.smtp_state.0.lock().unwrap().suspended = suspend;
if 0 != suspend { if 0 != suspend {
@@ -305,19 +285,13 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
let mut buf: *mut libc::c_void = 0 as *mut libc::c_void; let mut buf: *mut libc::c_void = 0 as *mut libc::c_void;
let mut buf_bytes: size_t = 0i32 as size_t; let mut buf_bytes: size_t = 0i32 as size_t;
let mut recipients: *mut libc::c_char = 0 as *mut libc::c_char; let mut recipients: *mut libc::c_char = 0 as *mut libc::c_char;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
/* connect to SMTP server, if not yet done */ /* connect to SMTP server, if not yet done */
if !context.smtp.lock().unwrap().is_connected() { if !context.smtp.lock().unwrap().is_connected() {
let loginparam: *mut dc_loginparam_t = dc_loginparam_new(); let loginparam = dc_loginparam_read(context, &context.sql, "configured_");
dc_loginparam_read( let connected = context.smtp.lock().unwrap().connect(context, &loginparam);
context,
loginparam, if connected {
&context.sql,
b"configured_\x00" as *const u8 as *const libc::c_char,
);
let connected = context.smtp.lock().unwrap().connect(context, loginparam);
dc_loginparam_unref(loginparam);
if !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);
current_block = 14216916617354591294; current_block = 14216916617354591294;
} else { } else {
@@ -330,21 +304,11 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
13109137661213826276 => { 13109137661213826276 => {
filename = dc_param_get(job.param, 'f' as i32, 0 as *const libc::c_char); filename = dc_param_get(job.param, 'f' as i32, 0 as *const libc::c_char);
if filename.is_null() { if filename.is_null() {
dc_log_warning( warn!(context, 0, "Missing file name for job {}", job.job_id,);
context,
0i32,
b"Missing file name for job %d\x00" as *const u8 as *const libc::c_char,
job.job_id,
);
} else if !(0 == dc_read_file(context, filename, &mut buf, &mut buf_bytes)) { } else if !(0 == dc_read_file(context, filename, &mut buf, &mut buf_bytes)) {
recipients = dc_param_get(job.param, 'R' as i32, 0 as *const libc::c_char); recipients = dc_param_get(job.param, 'R' as i32, 0 as *const libc::c_char);
if recipients.is_null() { if recipients.is_null() {
dc_log_warning( warn!(context, 0, "Missing recipients for job {}", job.job_id,);
context,
0i32,
b"Missing recipients for job %d\x00" as *const u8 as *const libc::c_char,
job.job_id,
);
} else { } else {
let recipients_list = std::ffi::CStr::from_ptr(recipients) let recipients_list = std::ffi::CStr::from_ptr(recipients)
.to_str() .to_str()
@@ -363,11 +327,10 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
before the generated mime was sent out */ before the generated mime was sent out */
if 0 != job.foreign_id { if 0 != job.foreign_id {
if 0 == dc_msg_exists(context, job.foreign_id) { if 0 == dc_msg_exists(context, job.foreign_id) {
dc_log_warning( warn!(
context, context,
0i32, 0,
b"Message %i for job %i does not exist\x00" as *const u8 "Message {} for job {} does not exist",
as *const libc::c_char,
job.foreign_id, job.foreign_id,
job.job_id, job.job_id,
); );
@@ -399,18 +362,14 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
dc_delete_file(context, filename); dc_delete_file(context, filename);
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( let chat_id: i32 = sql::query_row(
context, context,
&context.sql, &context.sql,
b"SELECT chat_id FROM msgs WHERE id=?\x00" as *const u8 "SELECT chat_id FROM msgs WHERE id=?",
as *const libc::c_char, params![job.foreign_id as i32],
); 0,
sqlite3_bind_int(stmt, 1i32, job.foreign_id as libc::c_int); )
let chat_id: libc::c_int = if sqlite3_step(stmt) == 100i32 { .unwrap_or_default();
sqlite3_column_int(stmt, 0i32)
} else {
0i32
};
context.call_cb( context.call_cb(
Event::MSG_DELIVERED, Event::MSG_DELIVERED,
chat_id as uintptr_t, chat_id as uintptr_t,
@@ -425,11 +384,11 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
} }
_ => {} _ => {}
} }
sqlite3_finalize(stmt);
free(recipients as *mut libc::c_void); free(recipients as *mut libc::c_void);
free(buf); free(buf);
free(filename as *mut libc::c_void); free(filename as *mut libc::c_void);
} }
// this value does not increase the number of tries // this value does not increase the number of tries
pub unsafe fn dc_job_try_again_later( pub unsafe fn dc_job_try_again_later(
job: &mut dc_job_t, job: &mut dc_job_t,
@@ -443,8 +402,7 @@ pub unsafe fn dc_job_try_again_later(
unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) { unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
let mut current_block: u64; let mut current_block: u64;
let msg: *mut dc_msg_t = dc_msg_new_untyped(context); let msg = 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; let mut dest_uid: uint32_t = 0i32 as uint32_t;
let inbox = context.inbox.read().unwrap(); let inbox = context.inbox.read().unwrap();
@@ -463,30 +421,20 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
match current_block { match current_block {
2473556513754201174 => { 2473556513754201174 => {
if dc_msg_load_from_db(msg, context, job.foreign_id) { if dc_msg_load_from_db(msg, context, job.foreign_id) {
if dc_sqlite3_get_config_int( if sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 {
context,
&context.sql,
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32,
) < 3i32
{
inbox.configure_folders(context, 0x1i32); inbox.configure_folders(context, 0x1i32);
} }
dest_folder = dc_sqlite3_get_config( let dest_folder =
context, sql::get_config(context, &context.sql, "configured_mvbox_folder", None);
&context.sql,
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if !dest_folder.is_null() { if let Some(dest_folder) = dest_folder {
let server_folder = as_str((*msg).server_folder); let server_folder = as_str((*msg).server_folder);
match inbox.mv( match inbox.mv(
context, context,
server_folder, server_folder,
(*msg).server_uid, (*msg).server_uid,
as_str(dest_folder), &dest_folder,
&mut dest_uid, &mut dest_uid,
) as libc::c_uint ) as libc::c_uint
{ {
@@ -497,7 +445,7 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
dc_update_server_uid( dc_update_server_uid(
context, context,
(*msg).rfc724_mid, (*msg).rfc724_mid,
dest_folder, &dest_folder,
dest_uid, dest_uid,
); );
} }
@@ -513,7 +461,7 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
dc_update_server_uid( dc_update_server_uid(
context, context,
(*msg).rfc724_mid, (*msg).rfc724_mid,
dest_folder, &dest_folder,
dest_uid, dest_uid,
); );
} }
@@ -529,18 +477,17 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
} }
_ => {} _ => {}
} }
free(dest_folder as *mut libc::c_void);
dc_msg_unref(msg); dc_msg_unref(msg);
} }
/* ****************************************************************************** /* ******************************************************************************
* IMAP-jobs * IMAP-jobs
******************************************************************************/ ******************************************************************************/
fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int { fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
let ret_connected: libc::c_int; let ret_connected = dc_connect_to_configured_imap(context, inbox);
if 0 != ret_connected {
ret_connected = unsafe { dc_connect_to_configured_imap(context, inbox) }; inbox.set_watch_folder("INBOX".into());
if !(0 == ret_connected) {
inbox.set_watch_folder(b"INBOX\x00" as *const u8 as *const libc::c_char);
} }
ret_connected ret_connected
} }
@@ -549,7 +496,6 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_
let current_block: u64; let current_block: u64;
let folder: *mut libc::c_char = dc_param_get(job.param, 'Z' as i32, 0 as *const libc::c_char); let folder: *mut libc::c_char = dc_param_get(job.param, 'Z' as i32, 0 as *const libc::c_char);
let uid: uint32_t = dc_param_get_int(job.param, 'z' as i32, 0i32) as uint32_t; let 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; let mut dest_uid: uint32_t = 0i32 as uint32_t;
let inbox = context.inbox.read().unwrap(); let inbox = context.inbox.read().unwrap();
@@ -571,23 +517,12 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_
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);
} }
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 sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 {
context,
&context.sql,
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0i32,
) < 3i32
{
inbox.configure_folders(context, 0x1i32); inbox.configure_folders(context, 0x1i32);
} }
dest_folder = dc_sqlite3_get_config( let dest_folder =
context, sql::get_config(context, &context.sql, "configured_mvbox_folder", None);
&context.sql, if let Some(dest_folder) = dest_folder {
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if !dest_folder.is_null() {
let dest_folder = as_str(dest_folder);
if 1 == inbox.mv(context, folder, uid, dest_folder, &mut dest_uid) if 1 == inbox.mv(context, folder, uid, dest_folder, &mut dest_uid)
as libc::c_uint as libc::c_uint
{ {
@@ -599,8 +534,8 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_
_ => {} _ => {}
} }
free(folder as *mut libc::c_void); free(folder as *mut libc::c_void);
free(dest_folder as *mut libc::c_void);
} }
unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_job_t) { unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_job_t) {
let mut current_block: u64; let mut current_block: u64;
let msg: *mut dc_msg_t = dc_msg_new_untyped(context); let msg: *mut dc_msg_t = dc_msg_new_untyped(context);
@@ -631,11 +566,11 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_
} }
_ => { _ => {
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 != sql::get_config_int(
context, context,
&context.sql, &context.sql,
b"mdns_enabled\x00" as *const u8 as *const libc::c_char, "mdns_enabled",
1i32, 1,
) )
{ {
let folder = let folder =
@@ -687,11 +622,11 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_
} }
_ => { _ => {
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 != sql::get_config_int(
context, context,
&context.sql, &context.sql,
b"mdns_enabled\x00" as *const u8 as *const libc::c_char, "mdns_enabled",
1i32, 1,
) )
{ {
let folder = let folder =
@@ -800,12 +735,11 @@ unsafe fn dc_add_smtp_job(
(*mimefactory).rfc724_mid, (*mimefactory).rfc724_mid,
); );
if pathNfilename.is_null() { if pathNfilename.is_null() {
dc_log_error( error!(
context, context,
0i32, 0,
b"Could not find free file name for message with ID <%s>.\x00" as *const u8 "Could not find free file name for message with ID <{}>.",
as *const libc::c_char, to_string((*mimefactory).rfc724_mid),
(*mimefactory).rfc724_mid,
); );
} else if 0 } else if 0
== dc_write_file( == dc_write_file(
@@ -815,12 +749,12 @@ unsafe fn dc_add_smtp_job(
(*(*mimefactory).out).len, (*(*mimefactory).out).len,
) )
{ {
dc_log_error( error!(
context, context,
0i32, 0,
b"Could not write message <%s> to \"%s\".\x00" as *const u8 as *const libc::c_char, "Could not write message <{}> to \"{}\".",
(*mimefactory).rfc724_mid, to_string((*mimefactory).rfc724_mid),
pathNfilename, as_str(pathNfilename),
); );
} else { } else {
recipients = dc_str_from_clist( recipients = dc_str_from_clist(
@@ -857,55 +791,41 @@ pub unsafe fn dc_job_add(
delay_seconds: libc::c_int, delay_seconds: libc::c_int,
) { ) {
let timestamp = time(); let timestamp = time();
let stmt: *mut sqlite3_stmt; let thread = if action >= 100 && action < 100 + 1000 {
let thread: libc::c_int; 100
if action >= 100i32 && action < 100i32 + 1000i32 { } else if action >= 5000 && action < 5000 + 1000 {
thread = 100i32 5000
} else if action >= 5000i32 && action < 5000i32 + 1000i32 {
thread = 5000i32
} else { } else {
return; return;
} };
stmt =
dc_sqlite3_prepare( sql::execute(
context, context,
&context.sql, &context.sql,
b"INSERT INTO jobs (added_timestamp, thread, action, foreign_id, param, desired_timestamp) VALUES (?,?,?,?,?,?);\x00" "INSERT INTO jobs (added_timestamp, thread, action, foreign_id, param, desired_timestamp) VALUES (?,?,?,?,?,?);",
as *const u8 as *const libc::c_char); params![
sqlite3_bind_int64(stmt, 1i32, timestamp as sqlite3_int64); timestamp,
sqlite3_bind_int(stmt, 2i32, thread); thread,
sqlite3_bind_int(stmt, 3i32, action); action,
sqlite3_bind_int(stmt, 4i32, foreign_id); foreign_id,
sqlite3_bind_text(
stmt,
5i32,
if !param.is_null() { if !param.is_null() {
param as_str(param)
} else { } else {
b"\x00" as *const u8 as *const libc::c_char ""
}, },
-1i32, (timestamp + delay_seconds as i64)
None, ]
); );
sqlite3_bind_int64(
stmt, if thread == 100 {
6i32,
(timestamp + delay_seconds as i64) as sqlite3_int64,
);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
if thread == 100i32 {
dc_interrupt_imap_idle(context); dc_interrupt_imap_idle(context);
} else { } else {
dc_interrupt_smtp_idle(context); dc_interrupt_smtp_idle(context);
}; }
} }
pub unsafe fn dc_interrupt_smtp_idle(context: &Context) { pub unsafe fn dc_interrupt_smtp_idle(context: &Context) {
dc_log_info( info!(context, 0, "Interrupting SMTP-idle...",);
context,
0i32,
b"Interrupting SMTP-idle...\x00" as *const u8 as *const libc::c_char,
);
let &(ref lock, ref cvar) = &*context.smtp_state.clone(); let &(ref lock, ref cvar) = &*context.smtp_state.clone();
let mut state = lock.lock().unwrap(); let mut state = lock.lock().unwrap();
@@ -916,11 +836,7 @@ pub unsafe fn dc_interrupt_smtp_idle(context: &Context) {
} }
pub unsafe fn dc_interrupt_imap_idle(context: &Context) { pub unsafe fn dc_interrupt_imap_idle(context: &Context) {
dc_log_info( info!(context, 0, "Interrupting IMAP-IDLE...",);
context,
0i32,
b"Interrupting IMAP-IDLE...\x00" as *const u8 as *const libc::c_char,
);
*context.perform_inbox_jobs_needed.write().unwrap() = 1; *context.perform_inbox_jobs_needed.write().unwrap() = 1;
context.inbox.read().unwrap().interrupt_idle(); context.inbox.read().unwrap().interrupt_idle();
@@ -938,11 +854,9 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context: &Context, job: &mut dc_jo
{ {
/* eg. device messages have no Message-ID */ /* eg. device messages have no Message-ID */
if dc_rfc724_mid_cnt(context, (*msg).rfc724_mid) != 1i32 { if dc_rfc724_mid_cnt(context, (*msg).rfc724_mid) != 1i32 {
dc_log_info( info!(
context, context,
0i32, 0, "The message is deleted from the server when all parts are deleted.",
b"The message is deleted from the server when all parts are deleted.\x00"
as *const u8 as *const libc::c_char,
); );
delete_from_server = 0i32 delete_from_server = 0i32
} }
@@ -986,58 +900,37 @@ unsafe fn dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP(context: &Context, job: &mut dc_jo
} }
/* delete all pending jobs with the given action */ /* delete all pending jobs with the given action */
pub unsafe fn dc_job_kill_action(context: &Context, action: libc::c_int) { pub fn dc_job_kill_action(context: &Context, action: libc::c_int) -> bool {
let stmt = dc_sqlite3_prepare( sql::execute(
context, context,
&context.sql, &context.sql,
b"DELETE FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char, "DELETE FROM jobs WHERE action=?;",
); params![action],
sqlite3_bind_int(stmt, 1i32, action); )
sqlite3_step(stmt);
sqlite3_finalize(stmt);
} }
pub unsafe fn dc_perform_imap_fetch(context: &Context) { pub unsafe fn dc_perform_imap_fetch(context: &Context) {
let inbox = context.inbox.read().unwrap(); let inbox = context.inbox.read().unwrap();
info!(context, 0, "dc_perform_imap_fetch got inbox"); let start = clock();
let start: libc::clock_t = clock();
if 0 == connect_to_inbox(context, &inbox) { if 0 == connect_to_inbox(context, &inbox) {
return; return;
} }
if dc_sqlite3_get_config_int( if sql::get_config_int(context, &context.sql, "inbox_watch", 1) == 0 {
context, info!(context, 0, "INBOX-watch disabled.",);
&context.sql,
b"inbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
) == 0i32
{
dc_log_info(
context,
0i32,
b"INBOX-watch disabled.\x00" as *const u8 as *const libc::c_char,
);
return; return;
} }
dc_log_info( info!(context, 0, "INBOX-fetch started...",);
context,
0i32,
b"INBOX-fetch started...\x00" as *const u8 as *const libc::c_char,
);
inbox.fetch(context); inbox.fetch(context);
if inbox.should_reconnect() { if inbox.should_reconnect() {
dc_log_info( info!(context, 0, "INBOX-fetch aborted, starting over...",);
context,
0i32,
b"INBOX-fetch aborted, starting over...\x00" as *const u8 as *const libc::c_char,
);
inbox.fetch(context); inbox.fetch(context);
} }
dc_log_info( info!(
context, context,
0i32, 0,
b"INBOX-fetch done in %.0f ms.\x00" as *const u8 as *const libc::c_char, "INBOX-fetch done in {:.4} ms.",
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 / 1000000 as libc::c_double,
); );
} }
@@ -1059,12 +952,7 @@ pub fn dc_perform_imap_idle(context: &Context) {
} }
pub unsafe fn dc_perform_mvbox_fetch(context: &Context) { pub unsafe fn dc_perform_mvbox_fetch(context: &Context) {
let use_network: libc::c_int = dc_sqlite3_get_config_int( let use_network = sql::get_config_int(context, &context.sql, "mvbox_watch", 1);
context,
&context.sql,
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_fetch( dc_jobthread_fetch(
context, context,
&mut context.mvbox_thread.clone().write().unwrap(), &mut context.mvbox_thread.clone().write().unwrap(),
@@ -1073,12 +961,8 @@ pub unsafe fn dc_perform_mvbox_fetch(context: &Context) {
} }
pub unsafe fn dc_perform_mvbox_idle(context: &Context) { pub unsafe fn dc_perform_mvbox_idle(context: &Context) {
let use_network: libc::c_int = dc_sqlite3_get_config_int( let use_network = sql::get_config_int(context, &context.sql, "mvbox_watch", 1);
context,
&context.sql,
b"mvbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_idle( dc_jobthread_idle(
context, context,
&context.mvbox_thread.clone().read().unwrap(), &context.mvbox_thread.clone().read().unwrap(),
@@ -1091,12 +975,7 @@ pub unsafe fn dc_interrupt_mvbox_idle(context: &Context) {
} }
pub unsafe fn dc_perform_sentbox_fetch(context: &Context) { pub unsafe fn dc_perform_sentbox_fetch(context: &Context) {
let use_network: libc::c_int = dc_sqlite3_get_config_int( let use_network = sql::get_config_int(context, &context.sql, "sentbox_watch", 1);
context,
&context.sql,
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_fetch( dc_jobthread_fetch(
context, context,
&mut context.sentbox_thread.clone().write().unwrap(), &mut context.sentbox_thread.clone().write().unwrap(),
@@ -1105,12 +984,7 @@ pub unsafe fn dc_perform_sentbox_fetch(context: &Context) {
} }
pub unsafe fn dc_perform_sentbox_idle(context: &Context) { pub unsafe fn dc_perform_sentbox_idle(context: &Context) {
let use_network: libc::c_int = dc_sqlite3_get_config_int( let use_network = sql::get_config_int(context, &context.sql, "sentbox_watch", 1);
context,
&context.sql,
b"sentbox_watch\x00" as *const u8 as *const libc::c_char,
1i32,
);
dc_jobthread_idle( dc_jobthread_idle(
context, context,
&context.sentbox_thread.clone().read().unwrap(), &context.sentbox_thread.clone().read().unwrap(),
@@ -1132,28 +1006,16 @@ pub unsafe fn dc_perform_smtp_jobs(context: &Context) {
state.perform_jobs_needed = 0; state.perform_jobs_needed = 0;
if 0 != state.suspended { if 0 != state.suspended {
dc_log_info( info!(context, 0, "SMTP-jobs suspended.",);
context,
0i32,
b"SMTP-jobs suspended.\x00" as *const u8 as *const libc::c_char,
);
return; return;
} }
state.doing_jobs = 1; state.doing_jobs = 1;
probe_smtp_network probe_smtp_network
}; };
dc_log_info( info!(context, 0, "SMTP-jobs started...",);
context,
0,
b"SMTP-jobs started...\x00" as *const u8 as *const libc::c_char,
);
dc_job_perform(context, 5000, probe_smtp_network); dc_job_perform(context, 5000, probe_smtp_network);
dc_log_info( info!(context, 0, "SMTP-jobs ended.");
context,
0i32,
b"SMTP-jobs ended.\x00" as *const u8 as *const libc::c_char,
);
{ {
let &(ref lock, _) = &*context.smtp_state.clone(); let &(ref lock, _) = &*context.smtp_state.clone();
@@ -1164,21 +1026,15 @@ pub unsafe fn dc_perform_smtp_jobs(context: &Context) {
} }
pub unsafe fn dc_perform_smtp_idle(context: &Context) { pub unsafe fn dc_perform_smtp_idle(context: &Context) {
dc_log_info( info!(context, 0, "SMTP-idle started...",);
context,
0i32,
b"SMTP-idle started...\x00" as *const u8 as *const libc::c_char,
);
{ {
let &(ref lock, ref cvar) = &*context.smtp_state.clone(); let &(ref lock, ref cvar) = &*context.smtp_state.clone();
let mut state = lock.lock().unwrap(); let mut state = lock.lock().unwrap();
if state.perform_jobs_needed == 1 { if state.perform_jobs_needed == 1 {
dc_log_info( info!(
context, context,
0, 0, "SMTP-idle will not be started because of waiting jobs.",
b"SMTP-idle will not be started because of waiting jobs.\x00" as *const u8
as *const libc::c_char,
); );
} else { } else {
let dur = get_next_wakeup_time(context, 5000); let dur = get_next_wakeup_time(context, 5000);
@@ -1196,26 +1052,20 @@ pub unsafe fn dc_perform_smtp_idle(context: &Context) {
} }
} }
dc_log_info( info!(context, 0, "SMTP-idle ended.",);
context,
0i32,
b"SMTP-idle ended.\x00" as *const u8 as *const libc::c_char,
);
} }
unsafe fn get_next_wakeup_time(context: &Context, thread: libc::c_int) -> Duration { unsafe fn get_next_wakeup_time(context: &Context, thread: libc::c_int) -> Duration {
let stmt = dc_sqlite3_prepare( let t: i64 = sql::query_row(
context, context,
&context.sql, &context.sql,
b"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;\x00" as *const u8 "SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;",
as *const libc::c_char, params![thread],
); 0,
sqlite3_bind_int(stmt, 1, thread); )
.unwrap_or_default();
let mut wakeup_time = Duration::new(10 * 60, 0); let mut wakeup_time = Duration::new(10 * 60, 0);
if sqlite3_step(stmt) == 100 {
let t = sqlite3_column_int(stmt, 0) as i64;
let now = time(); let now = time();
if t > 0 { if t > 0 {
if t > now { if t > now {
@@ -1224,9 +1074,7 @@ unsafe fn get_next_wakeup_time(context: &Context, thread: libc::c_int) -> Durati
wakeup_time = Duration::new(0, 0); wakeup_time = Duration::new(0, 0);
} }
} }
}
sqlite3_finalize(stmt);
wakeup_time wakeup_time
} }
@@ -1245,19 +1093,13 @@ pub unsafe fn dc_maybe_network(context: &Context) {
dc_interrupt_sentbox_idle(context); dc_interrupt_sentbox_idle(context);
} }
pub unsafe fn dc_job_action_exists(context: &Context, action: libc::c_int) -> libc::c_int { pub fn dc_job_action_exists(context: &Context, action: libc::c_int) -> bool {
let job_exists: libc::c_int; context
let stmt; .sql
stmt = dc_sqlite3_prepare( .exists("SELECT id FROM jobs WHERE action=?;", params![action])
context, .unwrap_or_default()
&context.sql,
b"SELECT id FROM jobs WHERE action=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, action);
job_exists = (sqlite3_step(stmt) == 100i32) as libc::c_int;
sqlite3_finalize(stmt);
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(context: &Context, msg_id: uint32_t) -> libc::c_int { pub unsafe fn dc_job_send_msg(context: &Context, msg_id: uint32_t) -> libc::c_int {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0i32;
@@ -1286,11 +1128,9 @@ pub unsafe fn dc_job_send_msg(context: &Context, msg_id: uint32_t) -> libc::c_in
dc_mimefactory_init(&mut mimefactory, context); dc_mimefactory_init(&mut mimefactory, context);
/* load message data */ /* load message data */
if 0 == dc_mimefactory_load_msg(&mut mimefactory, msg_id) || mimefactory.from_addr.is_null() { if 0 == dc_mimefactory_load_msg(&mut mimefactory, msg_id) || mimefactory.from_addr.is_null() {
dc_log_warning( warn!(
context, context,
0i32, 0, "Cannot load data to send, maybe the message is deleted in between.",
b"Cannot load data to send, maybe the message is deleted in between.\x00" as *const u8
as *const libc::c_char,
); );
} else { } else {
// no redo, no IMAP. moreover, as the data does not exist, there is no need in calling dc_set_msg_failed() // no redo, no IMAP. moreover, as the data does not exist, there is no need in calling dc_set_msg_failed()
@@ -1341,9 +1181,16 @@ pub unsafe fn dc_job_send_msg(context: &Context, msg_id: uint32_t) -> libc::c_in
/* create message */ /* create message */
if 0 == dc_mimefactory_render(&mut mimefactory) { if 0 == dc_mimefactory_render(&mut mimefactory) {
dc_set_msg_failed(context, msg_id, mimefactory.error); dc_set_msg_failed(context, msg_id, mimefactory.error);
} else if 0 != dc_param_get_int((*mimefactory.msg).param, 'c' as i32, 0i32) } else if 0 != dc_param_get_int((*mimefactory.msg).param, 'c' as i32, 0)
&& 0 == mimefactory.out_encrypted && 0 == mimefactory.out_encrypted
{ {
warn!(
context,
0,
"e2e encryption unavailable {} - {}",
msg_id,
dc_param_get_int((*mimefactory.msg).param, 'c' as i32, 0),
);
dc_set_msg_failed( dc_set_msg_failed(
context, context,
msg_id, msg_id,

30
src/dc_jobthread.rs
View File

@@ -2,11 +2,9 @@ use std::sync::{Arc, Condvar, Mutex};
use crate::context::Context; use crate::context::Context;
use crate::dc_configure::*; use crate::dc_configure::*;
use crate::dc_sqlite3::*;
use crate::imap::Imap; use crate::imap::Imap;
use crate::types::*; use crate::sql;
use crate::x::*; use crate::x::*;
use std::ffi::CString;
#[repr(C)] #[repr(C)]
pub struct dc_jobthread_t { pub struct dc_jobthread_t {
@@ -133,39 +131,25 @@ pub unsafe fn dc_jobthread_fetch(
unsafe fn connect_to_imap(context: &Context, jobthread: &dc_jobthread_t) -> libc::c_int { unsafe fn connect_to_imap(context: &Context, jobthread: &dc_jobthread_t) -> libc::c_int {
let mut ret_connected: libc::c_int; let mut ret_connected: libc::c_int;
let mut mvbox_name: *mut libc::c_char = 0 as *mut libc::c_char;
if jobthread.imap.is_connected() { if jobthread.imap.is_connected() {
ret_connected = 1; ret_connected = 1;
} else { } else {
ret_connected = dc_connect_to_configured_imap(context, &jobthread.imap); ret_connected = dc_connect_to_configured_imap(context, &jobthread.imap);
if !(0 == ret_connected) { if !(0 == ret_connected) {
if dc_sqlite3_get_config_int( if sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 {
context,
&context.sql,
b"folders_configured\x00" as *const u8 as *const libc::c_char,
0,
) < 3
{
jobthread.imap.configure_folders(context, 0x1); jobthread.imap.configure_folders(context, 0x1);
} }
mvbox_name = dc_sqlite3_get_config( let mvbox_name =
context, sql::get_config(context, &context.sql, jobthread.folder_config_name, None);
&context.sql, if let Some(name) = mvbox_name {
CString::new(&jobthread.folder_config_name[..]) jobthread.imap.set_watch_folder(name);
.unwrap() } else {
.as_ptr(),
0 as *const libc::c_char,
);
if mvbox_name.is_null() {
jobthread.imap.disconnect(context); jobthread.imap.disconnect(context);
ret_connected = 0; ret_connected = 0;
} else {
jobthread.imap.set_watch_folder(mvbox_name);
} }
} }
} }
free(mvbox_name as *mut libc::c_void);
ret_connected ret_connected
} }

704
src/dc_location.rs
View File

@@ -3,13 +3,12 @@ use crate::context::*;
use crate::dc_array::*; use crate::dc_array::*;
use crate::dc_chat::*; use crate::dc_chat::*;
use crate::dc_job::*; use crate::dc_job::*;
use crate::dc_log::*;
use crate::dc_msg::*; use crate::dc_msg::*;
use crate::dc_param::*; use crate::dc_param::*;
use crate::dc_saxparser::*; use crate::dc_saxparser::*;
use crate::dc_sqlite3::*;
use crate::dc_stock::*; use crate::dc_stock::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -43,47 +42,41 @@ pub unsafe fn dc_send_locations_to_chat(
chat_id: uint32_t, chat_id: uint32_t,
seconds: libc::c_int, seconds: libc::c_int,
) { ) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let now = time(); let now = time();
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 is_sending_locations_before: libc::c_int; let is_sending_locations_before: bool;
if !(seconds < 0i32 || chat_id <= 9i32 as libc::c_uint) { if !(seconds < 0i32 || chat_id <= 9i32 as libc::c_uint) {
is_sending_locations_before = dc_is_sending_locations_to_chat(context, chat_id); is_sending_locations_before = dc_is_sending_locations_to_chat(context, chat_id);
stmt = if sql::execute(
dc_sqlite3_prepare(
context, context,
&context.sql, &context.sql,
b"UPDATE chats SET locations_send_begin=?, locations_send_until=? WHERE id=?\x00" "UPDATE chats \
as *const u8 as *const libc::c_char); SET locations_send_begin=?, \
sqlite3_bind_int64( locations_send_until=? \
stmt, WHERE id=?",
1i32, params![
(if 0 != seconds { now } else { 0 }) as sqlite3_int64, if 0 != seconds { now } else { 0 },
); if 0 != seconds {
sqlite3_bind_int64(
stmt,
2i32,
(if 0 != seconds {
now + seconds as i64 now + seconds as i64
} else { } else {
0 0
}) as sqlite3_int64, },
); chat_id as i32,
sqlite3_bind_int(stmt, 3i32, chat_id as libc::c_int); ],
sqlite3_step(stmt); ) {
if 0 != seconds && 0 == is_sending_locations_before { if 0 != seconds && !is_sending_locations_before {
msg = dc_msg_new(context, 10i32); msg = dc_msg_new(context, 10i32);
(*msg).text = dc_stock_system_msg( (*msg).text = dc_stock_system_msg(
context, context,
64i32, 64,
0 as *const libc::c_char, 0 as *const libc::c_char,
0 as *const libc::c_char, 0 as *const libc::c_char,
0i32 as uint32_t, 0,
); );
dc_param_set_int((*msg).param, 'S' as i32, 8i32); dc_param_set_int((*msg).param, 'S' as i32, 8i32);
dc_send_msg(context, chat_id, msg); dc_send_msg(context, chat_id, msg);
} else if 0 == seconds && 0 != is_sending_locations_before { } else if 0 == seconds && is_sending_locations_before {
stock_str = dc_stock_system_msg( stock_str = dc_stock_system_msg(
context, context,
65i32, 65i32,
@@ -109,270 +102,210 @@ pub unsafe fn dc_send_locations_to_chat(
); );
} }
} }
}
free(stock_str as *mut libc::c_void); free(stock_str as *mut libc::c_void);
dc_msg_unref(msg); dc_msg_unref(msg);
sqlite3_finalize(stmt);
} }
/******************************************************************************* /*******************************************************************************
* job to send locations out to all chats that want them * job to send locations out to all chats that want them
******************************************************************************/ ******************************************************************************/
unsafe fn schedule_MAYBE_SEND_LOCATIONS(context: &Context, flags: libc::c_int) { unsafe fn schedule_MAYBE_SEND_LOCATIONS(context: &Context, flags: libc::c_int) {
if 0 != flags & 0x1i32 || 0 == dc_job_action_exists(context, 5005i32) { if 0 != flags & 0x1 || !dc_job_action_exists(context, 5005) {
dc_job_add(context, 5005i32, 0i32, 0 as *const libc::c_char, 60i32); dc_job_add(context, 5005, 0, 0 as *const libc::c_char, 60);
}; };
} }
pub unsafe fn dc_is_sending_locations_to_chat(context: &Context, chat_id: uint32_t) -> libc::c_int { pub fn dc_is_sending_locations_to_chat(context: &Context, chat_id: u32) -> bool {
let mut is_sending_locations: libc::c_int = 0i32; context
let stmt: *mut sqlite3_stmt; .sql
.exists(
stmt = dc_sqlite3_prepare( "SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;",
context, params![if chat_id == 0 { 1 } else { 0 }, chat_id as i32, time()],
&context.sql, )
b"SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;\x00" as *const u8 .unwrap_or_default()
as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int64(stmt, 3i32, time() as sqlite3_int64);
if !(sqlite3_step(stmt) != 100i32) {
is_sending_locations = 1i32
}
sqlite3_finalize(stmt);
is_sending_locations
} }
pub unsafe fn dc_set_location( pub fn dc_set_location(
context: &Context, context: &Context,
latitude: libc::c_double, latitude: libc::c_double,
longitude: libc::c_double, longitude: libc::c_double,
accuracy: libc::c_double, accuracy: libc::c_double,
) -> libc::c_int { ) -> libc::c_int {
let mut stmt_chats: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; if latitude == 0.0 && longitude == 0.0 {
let mut stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; return 1;
let mut continue_streaming: libc::c_int = 0i32;
if latitude == 0.0f64 && longitude == 0.0f64 {
continue_streaming = 1i32
} else {
stmt_chats = dc_sqlite3_prepare(
context,
&context.sql,
b"SELECT id FROM chats WHERE locations_send_until>?;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int64(stmt_chats, 1i32, time() as sqlite3_int64);
while sqlite3_step(stmt_chats) == 100i32 {
let chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
stmt_insert =
dc_sqlite3_prepare(
context,
&context.sql,
b"INSERT INTO locations (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_double(stmt_insert, 1i32, latitude);
sqlite3_bind_double(stmt_insert, 2i32, longitude);
sqlite3_bind_double(stmt_insert, 3i32, accuracy);
sqlite3_bind_int64(stmt_insert, 4i32, time() as sqlite3_int64);
sqlite3_bind_int(stmt_insert, 5i32, chat_id as libc::c_int);
sqlite3_bind_int(stmt_insert, 6i32, 1i32);
sqlite3_step(stmt_insert);
continue_streaming = 1i32
} }
if 0 != continue_streaming {
context.call_cb(
Event::LOCATION_CHANGED,
1i32 as uintptr_t,
0i32 as uintptr_t,
);
schedule_MAYBE_SEND_LOCATIONS(context, 0i32);
}
}
sqlite3_finalize(stmt_chats);
sqlite3_finalize(stmt_insert);
continue_streaming context.sql.query_map(
"SELECT id FROM chats WHERE locations_send_until>?;",
params![time()], |row| row.get::<_, i32>(0),
|chats| {
let mut continue_streaming = false;
for chat in chats {
let chat_id = chat?;
context.sql.execute(
"INSERT INTO locations \
(latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);",
params![
latitude,
longitude,
accuracy,
time(),
chat_id,
1,
]
)?;
continue_streaming = true;
}
if continue_streaming {
context.call_cb(Event::LOCATION_CHANGED, 1, 0);
};
unsafe { schedule_MAYBE_SEND_LOCATIONS(context, 0) };
Ok(continue_streaming as libc::c_int)
}
).unwrap_or_default()
} }
pub unsafe fn dc_get_locations( pub fn dc_get_locations(
context: &Context, context: &Context,
chat_id: uint32_t, chat_id: uint32_t,
contact_id: uint32_t, contact_id: uint32_t,
timestamp_from: i64, timestamp_from: i64,
mut timestamp_to: i64, mut timestamp_to: i64,
) -> *mut dc_array_t { ) -> *mut dc_array_t {
let ret: *mut dc_array_t = dc_array_new_typed(1i32, 500i32 as size_t);
let stmt: *mut sqlite3_stmt;
if timestamp_to == 0 { if timestamp_to == 0 {
timestamp_to = time() + 10; timestamp_to = time() + 10;
} }
stmt = dc_sqlite3_prepare(
context, context
&context.sql, .sql
b"SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent, \ .query_map(
"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=?) \
AND (? OR l.from_id=?) \ AND (? OR l.from_id=?) \
AND (l.independent=1 OR (l.timestamp>=? AND l.timestamp<=?)) \ AND (l.independent=1 OR (l.timestamp>=? AND l.timestamp<=?)) \
ORDER BY l.timestamp DESC, l.id DESC, m.id DESC;\x00" as *const u8 ORDER BY l.timestamp DESC, l.id DESC, m.id DESC;",
as *const libc::c_char, params![
); if chat_id == 0 { 1 } else { 0 },
sqlite3_bind_int( chat_id as i32,
stmt, if contact_id == 0 { 1 } else { 0 },
1i32, contact_id as i32,
if chat_id == 0i32 as libc::c_uint { timestamp_from,
1i32 timestamp_to,
} else { ],
0i32 |row| unsafe {
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int(
stmt,
3i32,
if contact_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 4i32, contact_id as libc::c_int);
sqlite3_bind_int(stmt, 5i32, timestamp_from as libc::c_int);
sqlite3_bind_int(stmt, 6i32, timestamp_to as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
let mut loc: *mut _dc_location = let mut loc: *mut _dc_location =
calloc(1, ::std::mem::size_of::<_dc_location>()) as *mut _dc_location; calloc(1, ::std::mem::size_of::<_dc_location>()) as *mut _dc_location;
if loc.is_null() { assert!(!loc.is_null(), "allocation failed");
break;
} (*loc).location_id = row.get(0)?;
(*loc).location_id = sqlite3_column_double(stmt, 0i32) as uint32_t; (*loc).latitude = row.get(1)?;
(*loc).latitude = sqlite3_column_double(stmt, 1i32); (*loc).longitude = row.get(2)?;
(*loc).longitude = sqlite3_column_double(stmt, 2i32); (*loc).accuracy = row.get(3)?;
(*loc).accuracy = sqlite3_column_double(stmt, 3i32); (*loc).timestamp = row.get(4)?;
(*loc).timestamp = sqlite3_column_int64(stmt, 4i32) as i64; (*loc).independent = row.get(5)?;
(*loc).independent = sqlite3_column_int(stmt, 5i32) as uint32_t; (*loc).msg_id = row.get(6)?;
(*loc).msg_id = sqlite3_column_int(stmt, 6i32) as uint32_t; (*loc).contact_id = row.get(7)?;
(*loc).contact_id = sqlite3_column_int(stmt, 7i32) as uint32_t; (*loc).chat_id = row.get(8)?;
(*loc).chat_id = sqlite3_column_int(stmt, 8i32) as uint32_t;
if 0 != (*loc).msg_id { if 0 != (*loc).msg_id {
let txt: *const libc::c_char = sqlite3_column_text(stmt, 9i32) as *const libc::c_char; let txt: String = row.get(9)?;
if 0 != is_marker(txt) { let txt_c = to_cstring(txt);
(*loc).marker = strdup(txt) if 0 != is_marker(txt_c.as_ptr()) {
(*loc).marker = strdup(txt_c.as_ptr());
} }
} }
dc_array_add_ptr(ret, loc as *mut libc::c_void); Ok(loc)
} },
|locations| {
let ret = unsafe { dc_array_new_typed(1, 500) };
sqlite3_finalize(stmt); for location in locations {
unsafe { dc_array_add_ptr(ret, location? as *mut libc::c_void) };
ret }
Ok(ret)
},
)
.unwrap_or_else(|_| std::ptr::null_mut())
} }
// TODO should be bool /rtn // TODO should be bool /rtn
unsafe fn is_marker(txt: *const libc::c_char) -> libc::c_int { unsafe fn is_marker(txt: *const libc::c_char) -> libc::c_int {
if !txt.is_null() { if !txt.is_null() {
let len: libc::c_int = dc_utf8_strlen(txt) as libc::c_int; let len: libc::c_int = dc_utf8_strlen(txt) as libc::c_int;
if len == 1i32 && *txt.offset(0isize) as libc::c_int != ' ' as i32 { if len == 1 && *txt.offset(0isize) as libc::c_int != ' ' as i32 {
return 1i32; return 1;
} }
} }
0 0
} }
pub unsafe fn dc_delete_all_locations(context: &Context) { pub fn dc_delete_all_locations(context: &Context) -> bool {
let stmt: *mut sqlite3_stmt; if !sql::execute(context, &context.sql, "DELETE FROM locations;", params![]) {
return false;
stmt = dc_sqlite3_prepare( }
context, context.call_cb(Event::LOCATION_CHANGED, 0, 0);
&context.sql, true
b"DELETE FROM locations;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
context.call_cb(
Event::LOCATION_CHANGED,
0i32 as uintptr_t,
0i32 as uintptr_t,
);
sqlite3_finalize(stmt);
} }
pub unsafe fn dc_get_location_kml( pub fn dc_get_location_kml(
context: &Context, context: &Context,
chat_id: uint32_t, chat_id: uint32_t,
last_added_location_id: *mut uint32_t, last_added_location_id: *mut uint32_t,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0;
let mut stmt: *mut sqlite3_stmt;
let self_addr: *mut libc::c_char;
let now = time(); let now = time();
let locations_send_begin: i64; let mut location_count: libc::c_int = 0;
let locations_send_until: i64;
let locations_last_sent: i64;
let mut location_count: libc::c_int = 0i32;
let mut ret = String::new(); let mut ret = String::new();
self_addr = dc_sqlite3_get_config( let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some(""));
context,
&context.sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
stmt =
dc_sqlite3_prepare(
context,
&context.sql,
b"SELECT locations_send_begin, locations_send_until, locations_last_sent FROM chats WHERE id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(stmt) != 100i32) {
locations_send_begin = sqlite3_column_int64(stmt, 0i32) as i64;
locations_send_until = sqlite3_column_int64(stmt, 1i32) as i64;
locations_last_sent = sqlite3_column_int64(stmt, 2i32) as i64;
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
if self_addr.is_none() {
return std::ptr::null_mut();
}
let self_addr = self_addr.unwrap();
if let Ok((locations_send_begin, locations_send_until, locations_last_sent)) = context.sql.query_row(
"SELECT locations_send_begin, locations_send_until, locations_last_sent FROM chats WHERE id=?;",
params![chat_id as i32], |row| {
let send_begin: i64 = row.get(0)?;
let send_until: i64 = row.get(1)?;
let last_sent: i64 = row.get(2)?;
Ok((send_begin, send_until, last_sent))
}
) {
if !(locations_send_begin == 0 || now > locations_send_until) { if !(locations_send_begin == 0 || now > locations_send_until) {
ret += &format!( ret += &format!(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"{}\">\n", "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"{}\">\n",
to_string(self_addr), self_addr,
); );
stmt = dc_sqlite3_prepare(
context, context.sql.query_map(
&context.sql, "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>=? \
AND (timestamp>=? OR timestamp=(SELECT MAX(timestamp) FROM locations WHERE from_id=?)) \ AND (timestamp>=? OR timestamp=(SELECT MAX(timestamp) FROM locations WHERE from_id=?)) \
AND independent=0 \ AND independent=0 \
GROUP BY timestamp \ GROUP BY timestamp \
ORDER BY timestamp;\x00" as *const u8 ORDER BY timestamp;",
as *const libc::c_char, params![1, locations_send_begin, locations_last_sent, 1],
); |row| {
let location_id: i32 = row.get(0)?;
let latitude: f64 = row.get(1)?;
let longitude: f64 = row.get(2)?;
let accuracy: f64 = row.get(3)?;
let timestamp = unsafe { get_kml_timestamp(row.get(4)?) };
sqlite3_bind_int(stmt, 1i32, 1i32); Ok((location_id, latitude, longitude, accuracy, timestamp))
sqlite3_bind_int64(stmt, 2i32, locations_send_begin as sqlite3_int64); },
sqlite3_bind_int64(stmt, 3i32, locations_last_sent as sqlite3_int64); |rows| {
sqlite3_bind_int(stmt, 4i32, 1i32); for row in rows {
while sqlite3_step(stmt) == 100i32 { let (location_id, latitude, longitude, accuracy, timestamp) = row?;
let location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let latitude = sqlite3_column_double(stmt, 1i32);
let longitude = sqlite3_column_double(stmt, 2i32);
let accuracy = sqlite3_column_double(stmt, 3i32);
let timestamp = get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as i64);
ret += &format!( ret += &format!(
"<Placemark><Timestamp><when>{}</when></Timestamp><Point><coordinates accuracy=\"{}\">{},{}</coordinates></Point></Placemark>\n\x00", "<Placemark><Timestamp><when>{}</when></Timestamp><Point><coordinates accuracy=\"{}\">{},{}</coordinates></Point></Placemark>\n\x00",
as_str(timestamp), as_str(timestamp),
@@ -382,22 +315,23 @@ pub unsafe fn dc_get_location_kml(
); );
location_count += 1; location_count += 1;
if !last_added_location_id.is_null() { if !last_added_location_id.is_null() {
*last_added_location_id = location_id unsafe { *last_added_location_id = location_id as u32 };
} }
free(timestamp as *mut libc::c_void); unsafe { free(timestamp as *mut libc::c_void) };
} }
if !(location_count == 0) { Ok(())
}
).unwrap(); // TODO: better error handling
}
}
if location_count > 0 {
ret += "</Document>\n</kml>"; ret += "</Document>\n</kml>";
success = 1; success = 1;
} }
}
}
sqlite3_finalize(stmt);
free(self_addr as *mut libc::c_void);
if 0 != success { if 0 != success {
strdup(to_cstring(ret).as_ptr()) unsafe { strdup(to_cstring(ret).as_ptr()) }
} else { } else {
0 as *mut libc::c_char 0 as *mut libc::c_char
} }
@@ -445,94 +379,81 @@ pub unsafe fn dc_get_message_kml(
ret ret
} }
pub unsafe fn dc_set_kml_sent_timestamp(context: &Context, chat_id: uint32_t, timestamp: i64) { pub fn dc_set_kml_sent_timestamp(context: &Context, chat_id: u32, timestamp: i64) -> bool {
let stmt = dc_sqlite3_prepare( sql::execute(
context, context,
&context.sql, &context.sql,
b"UPDATE chats SET locations_last_sent=? WHERE id=?;\x00" as *const u8 "UPDATE chats SET locations_last_sent=? WHERE id=?;",
as *const libc::c_char, params![timestamp, chat_id as i32],
); )
sqlite3_bind_int64(stmt, 1i32, timestamp as sqlite3_int64);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
} }
pub unsafe fn dc_set_msg_location_id(context: &Context, msg_id: uint32_t, location_id: uint32_t) { pub fn dc_set_msg_location_id(context: &Context, msg_id: u32, location_id: u32) -> bool {
let stmt: *mut sqlite3_stmt; sql::execute(
stmt = dc_sqlite3_prepare(
context, context,
&context.sql, &context.sql,
b"UPDATE msgs SET location_id=? WHERE id=?;\x00" as *const u8 as *const libc::c_char, "UPDATE msgs SET location_id=? WHERE id=?;",
); params![location_id, msg_id as i32],
sqlite3_bind_int64(stmt, 1i32, location_id as sqlite3_int64); )
sqlite3_bind_int(stmt, 2i32, msg_id as libc::c_int);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
} }
pub unsafe fn dc_save_locations( pub unsafe fn dc_save_locations(
context: &Context, context: &Context,
chat_id: uint32_t, chat_id: u32,
contact_id: uint32_t, contact_id: u32,
locations: *const dc_array_t, locations: *const dc_array_t,
independent: libc::c_int, independent: libc::c_int,
) -> uint32_t { ) -> u32 {
let mut stmt_test: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; if chat_id <= 9 || locations.is_null() {
let mut stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; return 0;
let mut newest_timestamp = 0;
let mut newest_location_id: uint32_t = 0i32 as uint32_t;
if !(chat_id <= 9i32 as libc::c_uint || locations.is_null()) {
stmt_test = dc_sqlite3_prepare(
context,
&context.sql,
b"SELECT id FROM locations WHERE timestamp=? AND from_id=?\x00" as *const u8
as *const libc::c_char,
);
stmt_insert = dc_sqlite3_prepare(
context,
&context.sql,
b"INSERT INTO locations\
(timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
VALUES (?,?,?,?,?,?,?);\x00" as *const u8 as *const libc::c_char,
);
let mut i = 0;
while i < dc_array_get_cnt(locations) {
let location: *mut dc_location_t =
dc_array_get_ptr(locations, i as size_t) as *mut dc_location_t;
sqlite3_reset(stmt_test);
sqlite3_bind_int64(stmt_test, 1i32, (*location).timestamp as sqlite3_int64);
sqlite3_bind_int(stmt_test, 2i32, contact_id as libc::c_int);
if independent | sqlite3_step(stmt_test) != 100i32 {
sqlite3_reset(stmt_insert);
sqlite3_bind_int64(stmt_insert, 1i32, (*location).timestamp as sqlite3_int64);
sqlite3_bind_int(stmt_insert, 2i32, contact_id as libc::c_int);
sqlite3_bind_int(stmt_insert, 3i32, chat_id as libc::c_int);
sqlite3_bind_double(stmt_insert, 4i32, (*location).latitude);
sqlite3_bind_double(stmt_insert, 5i32, (*location).longitude);
sqlite3_bind_double(stmt_insert, 6i32, (*location).accuracy);
sqlite3_bind_double(stmt_insert, 7i32, independent as libc::c_double);
sqlite3_step(stmt_insert);
} }
context
.sql
.prepare2(
"SELECT id FROM locations WHERE timestamp=? AND from_id=?",
"INSERT INTO locations\
(timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
VALUES (?,?,?,?,?,?,?);",
|mut stmt_test, mut stmt_insert, conn| {
let mut newest_timestamp = 0;
let mut newest_location_id = 0;
for i in 0..dc_array_get_cnt(locations) {
let location = dc_array_get_ptr(locations, i as size_t) as *mut dc_location_t;
let exists =
stmt_test.exists(params![(*location).timestamp, contact_id as i32])?;
if 0 != independent || !exists {
stmt_insert.execute(params![
(*location).timestamp,
contact_id as i32,
chat_id as i32,
(*location).latitude,
(*location).longitude,
(*location).accuracy,
independent,
])?;
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 = sql::get_rowid2_with_conn(
context, context,
&context.sql, conn,
b"locations\x00" as *const u8 as *const libc::c_char, "locations",
b"timestamp\x00" as *const u8 as *const libc::c_char, "timestamp",
(*location).timestamp as uint64_t, (*location).timestamp,
b"from_id\x00" as *const u8 as *const libc::c_char, "from_id",
contact_id, contact_id as i32,
);
}
}
}
Ok(newest_location_id)
},
) )
} .unwrap_or_default()
i += 1
}
}
sqlite3_finalize(stmt_test);
sqlite3_finalize(stmt_insert);
newest_location_id
} }
pub unsafe fn dc_kml_parse( pub unsafe fn dc_kml_parse(
@@ -550,12 +471,9 @@ pub unsafe fn dc_kml_parse(
}; };
if content_bytes > (1 * 1024 * 1024) { if content_bytes > (1 * 1024 * 1024) {
dc_log_warning( warn!(
context, context,
0, 0, "A kml-files with {} bytes is larger than reasonably expected.", content_bytes,
b"A kml-files with %i bytes is larger than reasonably expected.\x00" as *const u8
as *const libc::c_char,
content_bytes,
); );
} 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);
@@ -616,15 +534,15 @@ unsafe fn kml_text_cb(userdata: *mut libc::c_void, text: *const libc::c_char, _l
(*kml).curr.timestamp = time(); (*kml).curr.timestamp = time();
} }
} }
} else if 0 != (*kml).tag & 0x10i32 { } else if 0 != (*kml).tag & 0x10 {
let mut comma: *mut libc::c_char = strchr(val, ',' as i32); let mut comma: *mut libc::c_char = strchr(val, ',' as i32);
if !comma.is_null() { if !comma.is_null() {
let longitude: *mut libc::c_char = val; let longitude: *mut libc::c_char = val;
let latitude: *mut libc::c_char = comma.offset(1isize); let latitude: *mut libc::c_char = comma.offset(1isize);
*comma = 0i32 as libc::c_char; *comma = 0 as libc::c_char;
comma = strchr(latitude, ',' as i32); comma = strchr(latitude, ',' as i32);
if !comma.is_null() { if !comma.is_null() {
*comma = 0i32 as libc::c_char *comma = 0 as libc::c_char
} }
(*kml).curr.latitude = dc_atof(latitude); (*kml).curr.latitude = dc_atof(latitude);
(*kml).curr.longitude = dc_atof(longitude) (*kml).curr.longitude = dc_atof(longitude)
@@ -636,8 +554,8 @@ unsafe fn kml_text_cb(userdata: *mut libc::c_void, text: *const libc::c_char, _l
unsafe fn kml_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char) { unsafe fn kml_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char) {
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 strcmp(tag, b"placemark\x00" as *const u8 as *const libc::c_char) == 0i32 { if strcmp(tag, b"placemark\x00" as *const u8 as *const libc::c_char) == 0 {
if 0 != (*kml).tag & 0x1i32 if 0 != (*kml).tag & 0x1
&& 0 != (*kml).curr.timestamp && 0 != (*kml).curr.timestamp
&& 0. != (*kml).curr.latitude && 0. != (*kml).curr.latitude
&& 0. != (*kml).curr.longitude && 0. != (*kml).curr.longitude
@@ -647,7 +565,7 @@ unsafe fn kml_endtag_cb(userdata: *mut libc::c_void, tag: *const libc::c_char) {
*location = (*kml).curr; *location = (*kml).curr;
dc_array_add_ptr((*kml).locations, location as *mut libc::c_void); dc_array_add_ptr((*kml).locations, location as *mut libc::c_void);
} }
(*kml).tag = 0i32 (*kml).tag = 0
}; };
} }
@@ -660,34 +578,34 @@ unsafe fn kml_starttag_cb(
attr: *mut *mut libc::c_char, attr: *mut *mut libc::c_char,
) { ) {
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 strcmp(tag, b"document\x00" as *const u8 as *const libc::c_char) == 0i32 { if strcmp(tag, b"document\x00" as *const u8 as *const libc::c_char) == 0 {
let addr: *const libc::c_char = let addr: *const libc::c_char =
dc_attr_find(attr, b"addr\x00" as *const u8 as *const libc::c_char); dc_attr_find(attr, b"addr\x00" as *const u8 as *const libc::c_char);
if !addr.is_null() { if !addr.is_null() {
(*kml).addr = dc_strdup(addr) (*kml).addr = dc_strdup(addr)
} }
} else if strcmp(tag, b"placemark\x00" as *const u8 as *const libc::c_char) == 0i32 { } else if strcmp(tag, b"placemark\x00" as *const u8 as *const libc::c_char) == 0 {
(*kml).tag = 0x1i32; (*kml).tag = 0x1;
(*kml).curr.timestamp = 0; (*kml).curr.timestamp = 0;
(*kml).curr.latitude = 0i32 as libc::c_double; (*kml).curr.latitude = 0 as libc::c_double;
(*kml).curr.longitude = 0.0f64; (*kml).curr.longitude = 0.0f64;
(*kml).curr.accuracy = 0.0f64 (*kml).curr.accuracy = 0.0f64
} else if strcmp(tag, b"timestamp\x00" as *const u8 as *const libc::c_char) == 0i32 } else if strcmp(tag, b"timestamp\x00" as *const u8 as *const libc::c_char) == 0
&& 0 != (*kml).tag & 0x1i32 && 0 != (*kml).tag & 0x1
{ {
(*kml).tag = 0x1i32 | 0x2i32 (*kml).tag = 0x1 | 0x2
} else if strcmp(tag, b"when\x00" as *const u8 as *const libc::c_char) == 0i32 } else if strcmp(tag, b"when\x00" as *const u8 as *const libc::c_char) == 0
&& 0 != (*kml).tag & 0x2i32 && 0 != (*kml).tag & 0x2
{ {
(*kml).tag = 0x1i32 | 0x2i32 | 0x4i32 (*kml).tag = 0x1 | 0x2 | 0x4
} else if strcmp(tag, b"point\x00" as *const u8 as *const libc::c_char) == 0i32 } else if strcmp(tag, b"point\x00" as *const u8 as *const libc::c_char) == 0
&& 0 != (*kml).tag & 0x1i32 && 0 != (*kml).tag & 0x1
{ {
(*kml).tag = 0x1i32 | 0x8i32 (*kml).tag = 0x1 | 0x8
} else if strcmp(tag, b"coordinates\x00" as *const u8 as *const libc::c_char) == 0i32 } else if strcmp(tag, b"coordinates\x00" as *const u8 as *const libc::c_char) == 0
&& 0 != (*kml).tag & 0x8i32 && 0 != (*kml).tag & 0x8
{ {
(*kml).tag = 0x1i32 | 0x8i32 | 0x10i32; (*kml).tag = 0x1 | 0x8 | 0x10;
let accuracy: *const libc::c_char = let accuracy: *const libc::c_char =
dc_attr_find(attr, b"accuracy\x00" as *const u8 as *const libc::c_char); dc_attr_find(attr, b"accuracy\x00" as *const u8 as *const libc::c_char);
if !accuracy.is_null() { if !accuracy.is_null() {
@@ -706,54 +624,56 @@ pub unsafe fn dc_kml_unref(kml: *mut dc_kml_t) {
} }
pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &Context, _job: *mut dc_job_t) { pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &Context, _job: *mut dc_job_t) {
let stmt_chats: *mut sqlite3_stmt;
let mut stmt_locations: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let now = time(); let now = time();
let mut continue_streaming: libc::c_int = 1i32; let mut continue_streaming: libc::c_int = 1;
dc_log_info( info!(
context, context,
0i32, 0, " ----------------- MAYBE_SEND_LOCATIONS -------------- ",
b" ----------------- MAYBE_SEND_LOCATIONS -------------- \x00" as *const u8
as *const libc::c_char,
); );
stmt_chats = dc_sqlite3_prepare(
context, context
&context.sql, .sql
b"SELECT id, locations_send_begin, locations_last_sent \ .query_map(
"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>?;",
); params![now],
sqlite3_bind_int64(stmt_chats, 1i32, now as sqlite3_int64); |row| {
while sqlite3_step(stmt_chats) == 100i32 { let chat_id: i32 = row.get(0)?;
let chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t; let locations_send_begin: i64 = row.get(1)?;
let locations_send_begin = sqlite3_column_int64(stmt_chats, 1i32) as i64; let locations_last_sent: i64 = row.get(2)?;
let locations_last_sent = sqlite3_column_int64(stmt_chats, 2i32) as i64; continue_streaming = 1;
continue_streaming = 1i32;
// be a bit tolerant as the timer may not align exactly with time(NULL) // be a bit tolerant as the timer may not align exactly with time(NULL)
if now - locations_last_sent < (60 - 3) { if now - locations_last_sent < (60 - 3) {
continue; Ok(None)
} else {
Ok(Some((chat_id, locations_send_begin, locations_last_sent)))
} }
if stmt_locations.is_null() { },
stmt_locations = dc_sqlite3_prepare( |rows| {
context, context.sql.prepare(
&context.sql, "SELECT id \
b"SELECT id \
FROM locations \ FROM locations \
WHERE from_id=? \ WHERE from_id=? \
AND timestamp>=? \ AND timestamp>=? \
AND timestamp>? \ AND timestamp>? \
AND independent=0 \ AND independent=0 \
ORDER BY timestamp;\x00" as *const u8 as *const libc::c_char, ORDER BY timestamp;",
); |mut stmt_locations| {
} else { for (chat_id, locations_send_begin, locations_last_sent) in
sqlite3_reset(stmt_locations); rows.filter_map(|r| match r {
} Ok(Some(v)) => Some(v),
sqlite3_bind_int(stmt_locations, 1i32, 1i32); _ => None,
sqlite3_bind_int64(stmt_locations, 2i32, locations_send_begin as sqlite3_int64); })
sqlite3_bind_int64(stmt_locations, 3i32, locations_last_sent as sqlite3_int64); {
// TODO: do I need to reset?
if !stmt_locations
.exists(params![1, locations_send_begin, locations_last_sent,])
.unwrap_or_default()
{
// if there is no new location, there's nothing to send. // if there is no new location, there's nothing to send.
// however, maybe we want to bypass this test eg. 15 minutes // however, maybe we want to bypass this test eg. 15 minutes
if sqlite3_step(stmt_locations) != 100i32 {
continue; continue;
} }
// pending locations are attached automatically to every message, // pending locations are attached automatically to every message,
@@ -765,71 +685,63 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &Context, _job: *mu
// the easiest way to determine this, is to check for an empty message queue. // the easiest way to determine this, is to check for an empty message queue.
// (might not be 100%, however, as positions are sent combined later // (might not be 100%, however, as positions are sent combined later
// and dc_set_location() is typically called periodically, this is ok) // and dc_set_location() is typically called periodically, this is ok)
let mut msg: *mut dc_msg_t = dc_msg_new(context, 10i32); let mut msg = dc_msg_new(context, 10);
(*msg).hidden = 1i32; (*msg).hidden = 1;
dc_param_set_int((*msg).param, 'S' as i32, 9i32); dc_param_set_int((*msg).param, 'S' as i32, 9);
dc_send_msg(context, chat_id, msg); dc_send_msg(context, chat_id as u32, msg);
dc_msg_unref(msg); dc_msg_unref(msg);
} }
Ok(())
},
)
},
)
.unwrap(); // TODO: Better error handling
if 0 != continue_streaming { if 0 != continue_streaming {
schedule_MAYBE_SEND_LOCATIONS(context, 0x1i32); schedule_MAYBE_SEND_LOCATIONS(context, 0x1);
} }
sqlite3_finalize(stmt_chats);
sqlite3_finalize(stmt_locations);
} }
pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context: &Context, job: &mut dc_job_t) { pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context: &Context, job: &mut dc_job_t) {
// this function is called when location-streaming _might_ have ended for a chat. // this function is called when location-streaming _might_ have ended for a chat.
// the function checks, if location-streaming is really ended; // the function checks, if location-streaming is really ended;
// if so, a device-message is added if not yet done. // if so, a device-message is added if not yet done.
let chat_id: uint32_t = (*job).foreign_id;
let locations_send_begin: i64; let chat_id = (*job).foreign_id;
let locations_send_until: i64; let mut stock_str = 0 as *mut libc::c_char;
let mut stmt;
let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char; if let Ok((send_begin, send_until)) = context.sql.query_row(
stmt = dc_sqlite3_prepare( "SELECT locations_send_begin, locations_send_until FROM chats WHERE id=?",
context, params![chat_id as i32],
&context.sql, |row| Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?)),
b"SELECT locations_send_begin, locations_send_until FROM chats WHERE id=?\x00" ) {
as *const u8 as *const libc::c_char, if !(send_begin != 0 && time() <= send_until) {
);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(stmt) != 100i32) {
locations_send_begin = sqlite3_column_int64(stmt, 0i32) as i64;
locations_send_until = sqlite3_column_int64(stmt, 1i32) as i64;
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
if !(locations_send_begin != 0 && time() <= locations_send_until) {
// still streaming - // still streaming -
// may happen as several calls to dc_send_locations_to_chat() // may happen as several calls to dc_send_locations_to_chat()
// do not un-schedule pending DC_MAYBE_SEND_LOC_ENDED jobs // do not un-schedule pending DC_MAYBE_SEND_LOC_ENDED jobs
if !(locations_send_begin == 0 && locations_send_until == 0) { if !(send_begin == 0 && send_until == 0) {
// not streaming, device-message already sent // not streaming, device-message already sent
stmt = if context.sql.execute(
dc_sqlite3_prepare( "UPDATE chats SET locations_send_begin=0, locations_send_until=0 WHERE id=?",
context, params![chat_id as i32],
&context.sql, ).is_ok() {
b"UPDATE chats SET locations_send_begin=0, locations_send_until=0 WHERE id=?\x00"
as *const u8 as
*const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
sqlite3_step(stmt);
stock_str = dc_stock_system_msg( stock_str = dc_stock_system_msg(
context, context,
65i32, 65,
0 as *const libc::c_char, 0 as *const libc::c_char,
0 as *const libc::c_char, 0 as *const libc::c_char,
0i32 as uint32_t, 0,
); );
dc_add_device_msg(context, chat_id, stock_str); dc_add_device_msg(context, chat_id, stock_str);
context.call_cb( context.call_cb(
Event::CHAT_MODIFIED, Event::CHAT_MODIFIED,
chat_id as uintptr_t, chat_id as usize,
0i32 as uintptr_t, 0,
); );
} }
} }
} }
sqlite3_finalize(stmt); }
free(stock_str as *mut libc::c_void); free(stock_str as *mut libc::c_void);
} }

142
src/dc_log.rs
View File

@@ -1,142 +0,0 @@
use crate::constants::Event;
use crate::context::Context;
use crate::dc_tools::*;
use crate::types::*;
use crate::x::*;
pub unsafe extern "C" fn dc_log_event(
context: &Context,
event_code: Event,
data1: libc::c_int,
msg: *const libc::c_char,
va: ...
) {
log_vprintf(context, event_code, data1, msg, va);
}
/* Asynchronous "Thread-errors" are reported by the dc_log_error()
function. These errors must be shown to the user by a bubble or so.
"Normal" errors are usually returned by a special value (null or so) and are
usually not reported using dc_log_error() - its up to the caller to
decide, what should be reported or done. However, these "Normal" errors
are usually logged by dc_log_warning(). */
unsafe fn log_vprintf(
context: &Context,
event: Event,
data1: libc::c_int,
msg_format: *const libc::c_char,
va_0: ::std::ffi::VaList,
) {
let msg: *mut libc::c_char;
if !msg_format.is_null() {
let mut tempbuf: [libc::c_char; 1025] = [0; 1025];
vsnprintf(
tempbuf.as_mut_ptr(),
1024i32 as libc::c_ulong,
msg_format,
va_0,
);
msg = dc_strdup(tempbuf.as_mut_ptr())
} else {
msg = dc_mprintf(
b"event #%i\x00" as *const u8 as *const libc::c_char,
event as libc::c_int,
)
}
context.call_cb(event, data1 as uintptr_t, msg as uintptr_t);
free(msg as *mut libc::c_void);
}
pub unsafe extern "C" fn dc_log_event_seq(
context: &Context,
event_code: Event,
sequence_start: *mut libc::c_int,
msg: *const libc::c_char,
va_0: ...
) {
if sequence_start.is_null() {
return;
}
log_vprintf(context, event_code, *sequence_start, msg, va_0);
*sequence_start = 0i32;
}
pub unsafe extern "C" fn dc_log_error(
context: &Context,
data1: libc::c_int,
msg: *const libc::c_char,
va_1: ...
) {
log_vprintf(context, Event::ERROR, data1, msg, va_1);
}
pub unsafe extern "C" fn dc_log_warning(
context: &Context,
data1: libc::c_int,
msg: *const libc::c_char,
va_2: ...
) {
log_vprintf(context, Event::WARNING, data1, msg, va_2);
}
pub unsafe extern "C" fn dc_log_info(
context: &Context,
data1: libc::c_int,
msg: *const libc::c_char,
va_3: ...
) {
log_vprintf(context, Event::INFO, data1, msg, va_3);
}
#[macro_export]
macro_rules! info {
($ctx:expr, $data1:expr, $msg:expr) => {
info!($ctx, $data1, $msg,)
};
($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {{
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($crate::constants::Event::INFO, $data1 as uintptr_t,
formatted_c.as_ptr() as uintptr_t)
}};
}
#[macro_export]
macro_rules! warn {
($ctx:expr, $data1:expr, $msg:expr) => {
warn!($ctx, $data1, $msg,)
};
($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($crate::constants::Event::WARNING, $data1 as libc::uintptr_t,
formatted_c.as_ptr() as libc::uintptr_t)
};
}
#[macro_export]
macro_rules! error {
($ctx:expr, $data1:expr, $msg:expr) => {
error!($ctx, $data1, $msg,)
};
($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($crate::constants::Event::ERROR, $data1 as uintptr_t,
formatted_c.as_ptr() as uintptr_t)
};
}
#[macro_export]
macro_rules! log_event {
($ctx:expr, $data1:expr, $msg:expr) => {
log_event!($ctx, $data1, $msg,)
};
($ctx:expr, $event:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($event, $data1 as uintptr_t,
formatted_c.as_ptr() as uintptr_t)
};
}

384
src/dc_loginparam.rs
View File

@@ -1,283 +1,167 @@
use crate::context::Context; use std::borrow::Cow;
use crate::dc_sqlite3::*;
use crate::dc_tools::*;
use crate::types::*;
use crate::x::*;
#[derive(Copy, Clone)] use crate::context::Context;
#[repr(C)] use crate::sql::{self, Sql};
#[derive(Default, Debug)]
pub struct dc_loginparam_t { pub struct dc_loginparam_t {
pub addr: *mut libc::c_char, pub addr: String,
pub mail_server: *mut libc::c_char, pub mail_server: String,
pub mail_user: *mut libc::c_char, pub mail_user: String,
pub mail_pw: *mut libc::c_char, pub mail_pw: String,
pub mail_port: i32, pub mail_port: i32,
pub send_server: *mut libc::c_char, pub send_server: String,
pub send_user: *mut libc::c_char, pub send_user: String,
pub send_pw: *mut libc::c_char, pub send_pw: String,
pub send_port: i32, pub send_port: i32,
pub server_flags: i32, pub server_flags: i32,
} }
pub unsafe fn dc_loginparam_new() -> *mut dc_loginparam_t { impl dc_loginparam_t {
let loginparam: *mut dc_loginparam_t; pub fn addr_str(&self) -> &str {
loginparam = calloc(1, ::std::mem::size_of::<dc_loginparam_t>()) as *mut dc_loginparam_t; self.addr.as_str()
assert!(!loginparam.is_null());
loginparam
}
pub unsafe fn dc_loginparam_unref(loginparam: *mut dc_loginparam_t) {
if loginparam.is_null() {
return;
} }
dc_loginparam_empty(loginparam);
free(loginparam as *mut libc::c_void);
} }
/* clears all data and frees its memory. All pointers are NULL after this function is called. */ pub fn dc_loginparam_new() -> dc_loginparam_t {
pub unsafe fn dc_loginparam_empty(mut loginparam: *mut dc_loginparam_t) { Default::default()
if loginparam.is_null() {
return;
}
free((*loginparam).addr as *mut libc::c_void);
(*loginparam).addr = 0 as *mut libc::c_char;
free((*loginparam).mail_server as *mut libc::c_void);
(*loginparam).mail_server = 0 as *mut libc::c_char;
(*loginparam).mail_port = 0i32;
free((*loginparam).mail_user as *mut libc::c_void);
(*loginparam).mail_user = 0 as *mut libc::c_char;
free((*loginparam).mail_pw as *mut libc::c_void);
(*loginparam).mail_pw = 0 as *mut libc::c_char;
free((*loginparam).send_server as *mut libc::c_void);
(*loginparam).send_server = 0 as *mut libc::c_char;
(*loginparam).send_port = 0i32;
free((*loginparam).send_user as *mut libc::c_void);
(*loginparam).send_user = 0 as *mut libc::c_char;
free((*loginparam).send_pw as *mut libc::c_void);
(*loginparam).send_pw = 0 as *mut libc::c_char;
(*loginparam).server_flags = 0i32;
} }
pub unsafe fn dc_loginparam_read( pub fn dc_loginparam_read(
context: &Context, context: &Context,
loginparam: *mut dc_loginparam_t, sql: &Sql,
sql: &SQLite, prefix: impl AsRef<str>,
prefix: *const libc::c_char, ) -> dc_loginparam_t {
) { let prefix = prefix.as_ref();
let mut key: *mut libc::c_char = 0 as *mut libc::c_char;
dc_loginparam_empty(loginparam);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"addr\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).addr = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_server\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_server = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_port\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_port = dc_sqlite3_get_config_int(context, sql, key, 0i32);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_user\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_user = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_pw\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).mail_pw = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_server\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_server = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_port\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_port = dc_sqlite3_get_config_int(context, sql, key, 0i32);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_user\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_user = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_pw\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).send_pw = dc_sqlite3_get_config(context, sql, key, 0 as *const libc::c_char);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"server_flags\x00" as *const u8 as *const libc::c_char,
);
(*loginparam).server_flags = dc_sqlite3_get_config_int(context, sql, key, 0i32);
sqlite3_free(key as *mut libc::c_void);
}
pub unsafe fn dc_loginparam_write( let key = format!("{}addr", prefix);
context: &Context, let addr = sql::get_config(context, sql, key, None)
loginparam: *const dc_loginparam_t, .unwrap_or_default()
sql: &SQLite, .trim()
prefix: *const libc::c_char, .to_string();
) {
let mut key: *mut libc::c_char = 0 as *mut libc::c_char;
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"addr\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(context, sql, key, (*loginparam).addr);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_server\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(context, sql, key, (*loginparam).mail_server);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_port\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config_int(context, sql, key, (*loginparam).mail_port);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_user\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(context, sql, key, (*loginparam).mail_user);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"mail_pw\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(context, sql, key, (*loginparam).mail_pw);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_server\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(context, sql, key, (*loginparam).send_server);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_port\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config_int(context, sql, key, (*loginparam).send_port);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_user\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(context, sql, key, (*loginparam).send_user);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"send_pw\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config(context, sql, key, (*loginparam).send_pw);
sqlite3_free(key as *mut libc::c_void);
key = sqlite3_mprintf(
b"%s%s\x00" as *const u8 as *const libc::c_char,
prefix,
b"server_flags\x00" as *const u8 as *const libc::c_char,
);
dc_sqlite3_set_config_int(context, sql, key, (*loginparam).server_flags);
sqlite3_free(key as *mut libc::c_void);
}
pub unsafe fn dc_loginparam_get_readable(loginparam: *const dc_loginparam_t) -> *mut libc::c_char { let key = format!("{}mail_server", prefix);
let unset: *const libc::c_char = b"0\x00" as *const u8 as *const libc::c_char; let mail_server = sql::get_config(context, sql, key, None).unwrap_or_default();
let pw: *const libc::c_char = b"***\x00" as *const u8 as *const libc::c_char;
if loginparam.is_null() { let key = format!("{}mail_port", prefix);
return dc_strdup(0 as *const libc::c_char); let mail_port = sql::get_config_int(context, sql, key, 0);
let key = format!("{}mail_user", prefix);
let mail_user = sql::get_config(context, sql, key, None).unwrap_or_default();
let key = format!("{}mail_pw", prefix);
let mail_pw = sql::get_config(context, sql, key, None).unwrap_or_default();
let key = format!("{}send_server", prefix);
let send_server = sql::get_config(context, sql, key, None).unwrap_or_default();
let key = format!("{}send_port", prefix);
let send_port = sql::get_config_int(context, sql, key, 0);
let key = format!("{}send_user", prefix);
let send_user = sql::get_config(context, sql, key, None).unwrap_or_default();
let key = format!("{}send_pw", prefix);
let send_pw = sql::get_config(context, sql, key, None).unwrap_or_default();
let key = format!("{}server_flags", prefix);
let server_flags = sql::get_config_int(context, sql, key, 0);
dc_loginparam_t {
addr: addr.to_string(),
mail_server,
mail_user,
mail_pw,
mail_port,
send_server,
send_user,
send_pw,
send_port,
server_flags,
} }
let flags_readable: *mut libc::c_char = get_readable_flags((*loginparam).server_flags); }
let ret: *mut libc::c_char = dc_mprintf(
b"%s %s:%s:%s:%i %s:%s:%s:%i %s\x00" as *const u8 as *const libc::c_char, pub fn dc_loginparam_write(
if !(*loginparam).addr.is_null() { context: &Context,
(*loginparam).addr loginparam: &dc_loginparam_t,
sql: &Sql,
prefix: impl AsRef<str>,
) {
let prefix = prefix.as_ref();
let key = format!("{}addr", prefix);
sql::set_config(context, sql, key, Some(&loginparam.addr));
let key = format!("{}mail_server", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_server));
let key = format!("{}mail_port", prefix);
sql::set_config_int(context, sql, key, loginparam.mail_port);
let key = format!("{}mail_user", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_user));
let key = format!("{}mail_pw", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_pw));
let key = format!("{}send_server", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_server));
let key = format!("{}send_port", prefix);
sql::set_config_int(context, sql, key, loginparam.send_port);
let key = format!("{}send_user", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_user));
let key = format!("{}send_pw", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_pw));
let key = format!("{}server_flags", prefix);
sql::set_config_int(context, sql, key, loginparam.server_flags);
}
fn unset_empty(s: &String) -> Cow<String> {
if s.is_empty() {
Cow::Owned("unset".to_string())
} else { } else {
unset Cow::Borrowed(s)
}, }
if !(*loginparam).mail_user.is_null() { }
(*loginparam).mail_user
} else { pub fn dc_loginparam_get_readable(loginparam: &dc_loginparam_t) -> String {
unset let unset = "0";
}, let pw = "***";
if !(*loginparam).mail_pw.is_null() {
let flags_readable = get_readable_flags(loginparam.server_flags);
format!(
"{} {}:{}:{}:{} {}:{}:{}:{} {}",
unset_empty(&loginparam.addr),
unset_empty(&loginparam.mail_user),
if !loginparam.mail_pw.is_empty() {
pw pw
} else { } else {
unset unset
}, },
if !(*loginparam).mail_server.is_null() { unset_empty(&loginparam.mail_server),
(*loginparam).mail_server loginparam.mail_port,
} else { unset_empty(&loginparam.send_user),
unset if !loginparam.send_pw.is_empty() {
},
(*loginparam).mail_port,
if !(*loginparam).send_user.is_null() {
(*loginparam).send_user
} else {
unset
},
if !(*loginparam).send_pw.is_null() {
pw pw
} else { } else {
unset unset
}, },
if !(*loginparam).send_server.is_null() { unset_empty(&loginparam.send_server),
(*loginparam).send_server loginparam.send_port,
} else {
unset
},
(*loginparam).send_port,
flags_readable, flags_readable,
); )
free(flags_readable as *mut libc::c_void);
ret
} }
fn get_readable_flags(flags: libc::c_int) -> *mut libc::c_char { fn get_readable_flags(flags: i32) -> String {
let mut res = String::new(); let mut res = String::new();
for bit in 0..31 { for bit in 0..31 {
if 0 != flags & 1 << bit { if 0 != flags & 1 << bit {
let mut flag_added: libc::c_int = 0; let mut flag_added = 0;
if 1 << bit == 0x2 { if 1 << bit == 0x2 {
res += "OAUTH2 "; res += "OAUTH2 ";
flag_added = 1; flag_added = 1;
@@ -319,5 +203,5 @@ fn get_readable_flags(flags: libc::c_int) -> *mut libc::c_char {
res += "0"; res += "0";
} }
unsafe { strdup(to_cstring(res).as_ptr()) } res
} }

375
src/dc_mimefactory.rs
View File

@@ -14,13 +14,12 @@ use crate::dc_chat::*;
use crate::dc_contact::*; use crate::dc_contact::*;
use crate::dc_e2ee::*; use crate::dc_e2ee::*;
use crate::dc_location::*; use crate::dc_location::*;
use crate::dc_log::*;
use crate::dc_msg::*; use crate::dc_msg::*;
use crate::dc_param::*; use crate::dc_param::*;
use crate::dc_sqlite3::*;
use crate::dc_stock::*; use crate::dc_stock::*;
use crate::dc_strencode::*; use crate::dc_strencode::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -100,7 +99,7 @@ pub unsafe fn dc_mimefactory_empty(mut factory: *mut dc_mimefactory_t) {
mmap_string_free((*factory).out); mmap_string_free((*factory).out);
(*factory).out = 0 as *mut MMAPString (*factory).out = 0 as *mut MMAPString
} }
(*factory).out_encrypted = 0i32; (*factory).out_encrypted = 0;
(*factory).loaded = DC_MF_NOTHING_LOADED; (*factory).loaded = DC_MF_NOTHING_LOADED;
free((*factory).error as *mut libc::c_void); free((*factory).error as *mut libc::c_void);
(*factory).error = 0 as *mut libc::c_char; (*factory).error = 0 as *mut libc::c_char;
@@ -111,9 +110,12 @@ pub unsafe fn dc_mimefactory_load_msg(
mut factory: *mut dc_mimefactory_t, mut factory: *mut dc_mimefactory_t,
msg_id: uint32_t, msg_id: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; if factory.is_null() || msg_id <= 9 || !(*factory).msg.is_null() {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; return 0;
if !(factory.is_null() || msg_id <= 9i32 as libc::c_uint || !(*factory).msg.is_null()) { }
let mut success = 0;
/*call empty() before */ /*call empty() before */
let context = (*factory).context; let context = (*factory).context;
(*factory).recipients_names = clist_new(); (*factory).recipients_names = clist_new();
@@ -124,7 +126,7 @@ pub unsafe fn dc_mimefactory_load_msg(
&& dc_chat_load_from_db((*factory).chat, (*(*factory).msg).chat_id) && dc_chat_load_from_db((*factory).chat, (*(*factory).msg).chat_id)
{ {
load_from(factory); load_from(factory);
(*factory).req_mdn = 0i32; (*factory).req_mdn = 0;
if 0 != dc_chat_is_self_talk((*factory).chat) { if 0 != dc_chat_is_self_talk((*factory).chat) {
clist_insert_after( clist_insert_after(
(*factory).recipients_names, (*factory).recipients_names,
@@ -137,56 +139,63 @@ pub unsafe fn dc_mimefactory_load_msg(
dc_strdup((*factory).from_addr) as *mut libc::c_void, dc_strdup((*factory).from_addr) as *mut libc::c_void,
); );
} else { } else {
stmt = context
dc_sqlite3_prepare( .sql
context, .query_map(
&context.sql, "SELECT c.authname, c.addr \
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" FROM chats_contacts cc \
as *const u8 as LEFT JOIN contacts c ON cc.contact_id=c.id \
*const libc::c_char); WHERE cc.chat_id=? AND cc.contact_id>9;",
sqlite3_bind_int(stmt, 1i32, (*(*factory).msg).chat_id as libc::c_int); params![(*(*factory).msg).chat_id as i32],
while sqlite3_step(stmt) == 100i32 { |row| {
let authname: *const libc::c_char = let authname: String = row.get(0)?;
sqlite3_column_text(stmt, 0i32) as *const libc::c_char; let addr: String = row.get(1)?;
let addr: *const libc::c_char = Ok((authname, addr))
sqlite3_column_text(stmt, 1i32) as *const libc::c_char; },
if clist_search_string_nocase((*factory).recipients_addr, addr) == 0i32 { |rows| {
for row in rows {
let (authname, addr) = row?;
let addr_c = to_cstring(addr);
if clist_search_string_nocase(
(*factory).recipients_addr,
addr_c.as_ptr(),
) == 0
{
clist_insert_after( clist_insert_after(
(*factory).recipients_names, (*factory).recipients_names,
(*(*factory).recipients_names).last, (*(*factory).recipients_names).last,
(if !authname.is_null() && 0 != *authname.offset(0isize) as libc::c_int if !authname.is_empty() {
{ dc_strdup(to_cstring(authname).as_ptr())
dc_strdup(authname)
} else { } else {
0 as *mut libc::c_char 0 as *mut libc::c_char
}) as *mut libc::c_void, } as *mut libc::c_void,
); );
clist_insert_after( clist_insert_after(
(*factory).recipients_addr, (*factory).recipients_addr,
(*(*factory).recipients_addr).last, (*(*factory).recipients_addr).last,
dc_strdup(addr) as *mut libc::c_void, dc_strdup(addr_c.as_ptr()) as *mut libc::c_void,
); );
} }
} }
sqlite3_finalize(stmt); Ok(())
let command: libc::c_int = },
dc_param_get_int((*(*factory).msg).param, 'S' as i32, 0i32); )
if command == 5i32 { .unwrap();
let email_to_remove: *mut libc::c_char = dc_param_get(
let command = dc_param_get_int((*(*factory).msg).param, 'S' as i32, 0);
if command == 5 {
let email_to_remove_c = dc_param_get(
(*(*factory).msg).param, (*(*factory).msg).param,
'E' as i32, 'E' as i32,
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
let self_addr: *mut libc::c_char = dc_sqlite3_get_config( let email_to_remove = to_string(email_to_remove_c);
context, let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some(""))
&context.sql, .unwrap_or_default();
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char, if !email_to_remove.is_empty() && email_to_remove != self_addr {
); if clist_search_string_nocase((*factory).recipients_addr, email_to_remove_c)
if !email_to_remove.is_null() && strcasecmp(email_to_remove, self_addr) != 0i32 == 0
{
if clist_search_string_nocase((*factory).recipients_addr, email_to_remove)
== 0i32
{ {
clist_insert_after( clist_insert_after(
(*factory).recipients_names, (*factory).recipients_names,
@@ -196,40 +205,35 @@ pub unsafe fn dc_mimefactory_load_msg(
clist_insert_after( clist_insert_after(
(*factory).recipients_addr, (*factory).recipients_addr,
(*(*factory).recipients_addr).last, (*(*factory).recipients_addr).last,
email_to_remove as *mut libc::c_void, email_to_remove_c as *mut libc::c_void,
); );
} }
} }
free(self_addr as *mut libc::c_void);
} }
if command != 6i32 if command != 6
&& command != 7i32 && command != 7
&& 0 != dc_sqlite3_get_config_int( && 0 != sql::get_config_int(context, &context.sql, "mdns_enabled", 1)
context,
&context.sql,
b"mdns_enabled\x00" as *const u8 as *const libc::c_char,
1i32,
)
{ {
(*factory).req_mdn = 1i32 (*factory).req_mdn = 1
} }
} }
stmt = dc_sqlite3_prepare(
context, let row = context.sql.query_row(
&context.sql, "SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?",
b"SELECT mime_in_reply_to, mime_references FROM msgs WHERE id=?\x00" as *const u8 params![(*(*factory).msg).id as i32],
as *const libc::c_char, |row| {
let in_reply_to: String = row.get(0)?;
let references: String = row.get(1)?;
Ok((in_reply_to, references))
},
); );
sqlite3_bind_int(stmt, 1i32, (*(*factory).msg).id as libc::c_int); if let Ok((in_reply_to, references)) = row {
if sqlite3_step(stmt) == 100i32 { (*factory).in_reply_to = dc_strdup(to_cstring(in_reply_to).as_ptr());
(*factory).in_reply_to = (*factory).references = dc_strdup(to_cstring(references).as_ptr());
dc_strdup(sqlite3_column_text(stmt, 0i32) as *const libc::c_char);
(*factory).references =
dc_strdup(sqlite3_column_text(stmt, 1i32) as *const libc::c_char)
} }
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt; success = 1;
success = 1i32;
(*factory).loaded = DC_MF_MSG_LOADED; (*factory).loaded = DC_MF_MSG_LOADED;
(*factory).timestamp = (*(*factory).msg).timestamp_sort; (*factory).timestamp = (*(*factory).msg).timestamp_sort;
(*factory).rfc724_mid = dc_strdup((*(*factory).msg).rfc724_mid) (*factory).rfc724_mid = dc_strdup((*(*factory).msg).rfc724_mid)
@@ -237,32 +241,49 @@ pub unsafe fn dc_mimefactory_load_msg(
if 0 != success { if 0 != success {
(*factory).increation = dc_msg_is_increation((*factory).msg) (*factory).increation = dc_msg_is_increation((*factory).msg)
} }
}
sqlite3_finalize(stmt); success
return success;
} }
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 = strdup(
to_cstring(
sql::get_config(
(*factory).context, (*factory).context,
&(*factory).context.sql, &(*factory).context.sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char, "configured_addr",
0 as *const libc::c_char, None,
)
.unwrap_or_default(),
)
.as_ptr(),
); );
(*factory).from_displayname = dc_sqlite3_get_config( (*factory).from_displayname = strdup(
to_cstring(
sql::get_config(
(*factory).context, (*factory).context,
&(*factory).context.sql, &(*factory).context.sql,
b"displayname\x00" as *const u8 as *const libc::c_char, "displayname",
0 as *const libc::c_char, None,
)
.unwrap_or_default(),
)
.as_ptr(),
); );
(*factory).selfstatus = dc_sqlite3_get_config( (*factory).selfstatus = strdup(
to_cstring(
sql::get_config(
(*factory).context, (*factory).context,
&(*factory).context.sql, &(*factory).context.sql,
b"selfstatus\x00" as *const u8 as *const libc::c_char, "selfstatus",
0 as *const libc::c_char, None,
)
.unwrap_or_default(),
)
.as_ptr(),
); );
if (*factory).selfstatus.is_null() { if (*factory).selfstatus.is_null() {
(*factory).selfstatus = dc_stock_str((*factory).context, 13i32) (*factory).selfstatus = dc_stock_str((*factory).context, 13)
}; };
} }
@@ -270,21 +291,23 @@ pub unsafe fn dc_mimefactory_load_mdn(
mut factory: *mut dc_mimefactory_t, mut factory: *mut dc_mimefactory_t,
msg_id: uint32_t, msg_id: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success: libc::c_int = 0i32; if factory.is_null() {
let mut contact: *mut dc_contact_t = 0 as *mut dc_contact_t; return 0;
if !factory.is_null() { }
let mut success = 0;
let mut contact = 0 as *mut dc_contact_t;
(*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((*factory).context); (*factory).msg = dc_msg_new_untyped((*factory).context);
if !(0 if 0 != sql::get_config_int(
== dc_sqlite3_get_config_int(
(*factory).context, (*factory).context,
&(*factory).context.sql, &(*factory).context.sql,
b"mdns_enabled\x00" as *const u8 as *const libc::c_char, "mdns_enabled",
1i32, 1,
)) ) {
{ // MDNs not enabled - check this is late, in the job. the use may have changed its choice while offline ...
/* MDNs not enabled - check this is late, in the job. the use may have changed its choice while offline ... */
contact = dc_contact_new((*factory).context); contact = dc_contact_new((*factory).context);
if !(!dc_msg_load_from_db((*factory).msg, (*factory).context, msg_id) if !(!dc_msg_load_from_db((*factory).msg, (*factory).context, msg_id)
|| !dc_contact_load_from_db( || !dc_contact_load_from_db(
@@ -293,9 +316,9 @@ pub unsafe fn dc_mimefactory_load_mdn(
(*(*factory).msg).from_id, (*(*factory).msg).from_id,
)) ))
{ {
if !(0 != (*contact).blocked || (*(*factory).msg).chat_id <= 9i32 as libc::c_uint) { if !(0 != (*contact).blocked || (*(*factory).msg).chat_id <= 9 as libc::c_uint) {
/* Do not send MDNs trash etc.; chats.blocked is already checked by the caller in dc_markseen_msgs() */ // Do not send MDNs trash etc.; chats.blocked is already checked by the caller in dc_markseen_msgs()
if !((*(*factory).msg).from_id <= 9i32 as libc::c_uint) { if !((*(*factory).msg).from_id <= 9 as libc::c_uint) {
clist_insert_after( clist_insert_after(
(*factory).recipients_names, (*factory).recipients_names,
(*(*factory).recipients_names).last, (*(*factory).recipients_names).last,
@@ -318,13 +341,13 @@ pub unsafe fn dc_mimefactory_load_mdn(
0 as *const libc::c_char, 0 as *const libc::c_char,
(*factory).from_addr, (*factory).from_addr,
); );
success = 1i32; success = 1;
(*factory).loaded = DC_MF_MDN_LOADED (*factory).loaded = DC_MF_MDN_LOADED
} }
} }
} }
} }
}
dc_contact_unref(contact); dc_contact_unref(contact);
success success
@@ -339,15 +362,15 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
let mut message_text: *mut libc::c_char = 0 as *mut libc::c_char; let mut message_text: *mut libc::c_char = 0 as *mut libc::c_char;
let mut message_text2: *mut libc::c_char = 0 as *mut libc::c_char; let mut message_text2: *mut libc::c_char = 0 as *mut libc::c_char;
let mut subject_str: *mut libc::c_char = 0 as *mut libc::c_char; let mut subject_str: *mut libc::c_char = 0 as *mut libc::c_char;
let mut afwd_email: libc::c_int = 0i32; let mut afwd_email: libc::c_int = 0;
let mut col: libc::c_int = 0i32; let mut col: libc::c_int = 0;
let mut success: libc::c_int = 0i32; let mut success: libc::c_int = 0;
let mut parts: libc::c_int = 0i32; let mut parts: libc::c_int = 0;
let mut e2ee_guaranteed: libc::c_int = 0i32; let mut e2ee_guaranteed: libc::c_int = 0;
let mut min_verified: libc::c_int = 0i32; let mut min_verified: libc::c_int = 0;
// 1=add Autocrypt-header (needed eg. for handshaking), 2=no Autocrypte-header (used for MDN) // 1=add Autocrypt-header (needed eg. for handshaking), 2=no Autocrypte-header (used for MDN)
let mut force_plaintext: libc::c_int = 0i32; let mut force_plaintext: libc::c_int = 0;
let mut do_gossip: libc::c_int = 0i32; let mut do_gossip: libc::c_int = 0;
let mut grpimage: *mut libc::c_char = 0 as *mut libc::c_char; let mut grpimage: *mut libc::c_char = 0 as *mut libc::c_char;
let mut e2ee_helper = dc_e2ee_helper_t { let mut e2ee_helper = dc_e2ee_helper_t {
encryption_successfull: 0, encryption_successfull: 0,
@@ -382,7 +405,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
let mut to: *mut mailimf_address_list = 0 as *mut mailimf_address_list; let mut to: *mut mailimf_address_list = 0 as *mut mailimf_address_list;
if !(*factory).recipients_names.is_null() if !(*factory).recipients_names.is_null()
&& !(*factory).recipients_addr.is_null() && !(*factory).recipients_addr.is_null()
&& (*(*factory).recipients_addr).count > 0i32 && (*(*factory).recipients_addr).count > 0
{ {
let mut iter1: *mut clistiter; let mut iter1: *mut clistiter;
let mut iter2: *mut clistiter; let mut iter2: *mut clistiter;
@@ -505,7 +528,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
let msg: *mut dc_msg_t = (*factory).msg; let msg: *mut dc_msg_t = (*factory).msg;
let mut meta_part: *mut mailmime = 0 as *mut mailmime; let mut meta_part: *mut mailmime = 0 as *mut mailmime;
let mut placeholdertext: *mut libc::c_char = 0 as *mut libc::c_char; let mut placeholdertext: *mut libc::c_char = 0 as *mut libc::c_char;
if (*chat).type_0 == 130i32 { if (*chat).type_0 == 130 {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
mailimf_field_new_custom( mailimf_field_new_custom(
@@ -513,23 +536,23 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
strdup(b"1\x00" as *const u8 as *const libc::c_char), strdup(b"1\x00" as *const u8 as *const libc::c_char),
), ),
); );
force_plaintext = 0i32; force_plaintext = 0;
e2ee_guaranteed = 1i32; e2ee_guaranteed = 1;
min_verified = 2i32 min_verified = 2
} else { } else {
force_plaintext = dc_param_get_int((*(*factory).msg).param, 'u' as i32, 0i32); force_plaintext = dc_param_get_int((*(*factory).msg).param, 'u' as i32, 0);
if force_plaintext == 0i32 { if force_plaintext == 0 {
e2ee_guaranteed = dc_param_get_int((*(*factory).msg).param, 'c' as i32, 0i32) e2ee_guaranteed = dc_param_get_int((*(*factory).msg).param, 'c' as i32, 0)
} }
} }
if (*chat).gossiped_timestamp == 0 if (*chat).gossiped_timestamp == 0
|| ((*chat).gossiped_timestamp + (2 * 24 * 60 * 60)) < time() || ((*chat).gossiped_timestamp + (2 * 24 * 60 * 60)) < time()
{ {
do_gossip = 1i32 do_gossip = 1
} }
/* build header etc. */ /* build header etc. */
let command: libc::c_int = dc_param_get_int((*msg).param, 'S' as i32, 0i32); let command: libc::c_int = dc_param_get_int((*msg).param, 'S' as i32, 0);
if (*chat).type_0 == 120i32 || (*chat).type_0 == 130i32 { if (*chat).type_0 == 120 || (*chat).type_0 == 130 {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
mailimf_field_new_custom( mailimf_field_new_custom(
@@ -544,7 +567,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
dc_encode_header_words((*chat).name), dc_encode_header_words((*chat).name),
), ),
); );
if command == 5i32 { if command == 5 {
let email_to_remove: *mut libc::c_char = let email_to_remove: *mut libc::c_char =
dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char); dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char);
if !email_to_remove.is_null() { if !email_to_remove.is_null() {
@@ -559,8 +582,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
), ),
); );
} }
} else if command == 4i32 { } else if command == 4 {
do_gossip = 1i32; do_gossip = 1;
let email_to_add: *mut libc::c_char = let email_to_add: *mut libc::c_char =
dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char); dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char);
if !email_to_add.is_null() { if !email_to_add.is_null() {
@@ -576,13 +599,12 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
); );
grpimage = dc_param_get((*chat).param, 'i' as i32, 0 as *const libc::c_char) grpimage = dc_param_get((*chat).param, 'i' as i32, 0 as *const libc::c_char)
} }
if 0 != dc_param_get_int((*msg).param, 'F' as i32, 0i32) & 0x1i32 { if 0 != dc_param_get_int((*msg).param, 'F' as i32, 0) & 0x1 {
dc_log_info( info!(
(*msg).context, (*msg).context,
0i32, 0,
b"sending secure-join message \'%s\' >>>>>>>>>>>>>>>>>>>>>>>>>\x00" "sending secure-join message \'{}\' >>>>>>>>>>>>>>>>>>>>>>>>>",
as *const u8 as *const libc::c_char, "vg-member-added",
b"vg-member-added\x00" as *const u8 as *const libc::c_char,
); );
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
@@ -592,7 +614,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
), ),
); );
} }
} else if command == 2i32 { } else if command == 2 {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
mailimf_field_new_custom( mailimf_field_new_custom(
@@ -606,7 +628,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
), ),
), ),
); );
} else if command == 3i32 { } else if command == 3 {
grpimage = dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char); grpimage = dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char);
if grpimage.is_null() { if grpimage.is_null() {
mailimf_fields_add( mailimf_fields_add(
@@ -619,7 +641,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
} }
} }
} }
if command == 8i32 { if command == 8 {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
mailimf_field_new_custom( mailimf_field_new_custom(
@@ -630,7 +652,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
), ),
); );
} }
if command == 6i32 { if command == 6 {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
mailimf_field_new_custom( mailimf_field_new_custom(
@@ -638,18 +660,17 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
strdup(b"v1\x00" as *const u8 as *const libc::c_char), strdup(b"v1\x00" as *const u8 as *const libc::c_char),
), ),
); );
placeholdertext = dc_stock_str((*factory).context, 43i32) placeholdertext = dc_stock_str((*factory).context, 43)
} }
if command == 7i32 { if command == 7 {
let step: *mut libc::c_char = let step: *mut libc::c_char =
dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char); dc_param_get((*msg).param, 'E' as i32, 0 as *const libc::c_char);
if !step.is_null() { if !step.is_null() {
dc_log_info( info!(
(*msg).context, (*msg).context,
0i32, 0,
b"sending secure-join message \'%s\' >>>>>>>>>>>>>>>>>>>>>>>>>\x00" "sending secure-join message \'{}\' >>>>>>>>>>>>>>>>>>>>>>>>>",
as *const u8 as *const libc::c_char, as_str(step),
step,
); );
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
@@ -667,12 +688,12 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
if strcmp( if strcmp(
step, step,
b"vg-request-with-auth\x00" as *const u8 as *const libc::c_char, b"vg-request-with-auth\x00" as *const u8 as *const libc::c_char,
) == 0i32 ) == 0
|| strcmp( || strcmp(
step, step,
b"vc-request-with-auth\x00" as *const u8 b"vc-request-with-auth\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
) == 0i32 ) == 0
{ {
strdup( strdup(
b"Secure-Join-Auth\x00" as *const u8 as *const libc::c_char, b"Secure-Join-Auth\x00" as *const u8 as *const libc::c_char,
@@ -718,7 +739,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
} }
if !grpimage.is_null() { if !grpimage.is_null() {
let mut meta: *mut dc_msg_t = dc_msg_new_untyped((*factory).context); let mut meta: *mut dc_msg_t = dc_msg_new_untyped((*factory).context);
(*meta).type_0 = 20i32; (*meta).type_0 = 20;
dc_param_set((*meta).param, 'f' as i32, grpimage); dc_param_set((*meta).param, 'f' as i32, grpimage);
let mut filename_as_sent: *mut libc::c_char = 0 as *mut libc::c_char; let mut filename_as_sent: *mut libc::c_char = 0 as *mut libc::c_char;
meta_part = build_body_file( meta_part = build_body_file(
@@ -737,8 +758,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
} }
dc_msg_unref(meta); dc_msg_unref(meta);
} }
if (*msg).type_0 == 41i32 || (*msg).type_0 == 40i32 || (*msg).type_0 == 50i32 { if (*msg).type_0 == 41 || (*msg).type_0 == 40 || (*msg).type_0 == 50 {
if (*msg).type_0 == 41i32 { if (*msg).type_0 == 41 {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
mailimf_field_new_custom( mailimf_field_new_custom(
@@ -747,8 +768,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
), ),
); );
} }
let duration_ms: libc::c_int = dc_param_get_int((*msg).param, 'd' as i32, 0i32); let duration_ms: libc::c_int = dc_param_get_int((*msg).param, 'd' as i32, 0);
if duration_ms > 0i32 { if duration_ms > 0 {
mailimf_fields_add( mailimf_fields_add(
imf_fields, imf_fields,
mailimf_field_new_custom( mailimf_field_new_custom(
@@ -813,18 +834,18 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
free(fwdhint as *mut libc::c_void); free(fwdhint as *mut libc::c_void);
free(placeholdertext as *mut libc::c_void); free(placeholdertext as *mut libc::c_void);
/* add attachment part */ /* add attachment part */
if (*msg).type_0 == 20i32 if (*msg).type_0 == 20
|| (*msg).type_0 == 21i32 || (*msg).type_0 == 21
|| (*msg).type_0 == 40i32 || (*msg).type_0 == 40
|| (*msg).type_0 == 41i32 || (*msg).type_0 == 41
|| (*msg).type_0 == 50i32 || (*msg).type_0 == 50
|| (*msg).type_0 == 60i32 || (*msg).type_0 == 60
{ {
if 0 == is_file_size_okay(msg) { if 0 == is_file_size_okay(msg) {
let error: *mut libc::c_char = dc_mprintf( let error: *mut libc::c_char = dc_mprintf(
b"Message exceeds the recommended %i MB.\x00" as *const u8 b"Message exceeds the recommended %i MB.\x00" as *const u8
as *const libc::c_char, as *const libc::c_char,
24i32 * 1024i32 * 1024i32 / 4i32 * 3i32 / 1000i32 / 1000i32, 24 * 1024 * 1024 / 4 * 3 / 1000 / 1000,
); );
set_error(factory, error); set_error(factory, error);
free(error as *mut libc::c_void); free(error as *mut libc::c_void);
@@ -844,7 +865,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
match current_block { match current_block {
11328123142868406523 => {} 11328123142868406523 => {}
_ => { _ => {
if parts == 0i32 { if parts == 0 {
set_error( set_error(
factory, factory,
b"Empty message.\x00" as *const u8 as *const libc::c_char, b"Empty message.\x00" as *const u8 as *const libc::c_char,
@@ -887,8 +908,8 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
} }
} }
if 0 != dc_is_sending_locations_to_chat((*msg).context, (*msg).chat_id) { if dc_is_sending_locations_to_chat((*msg).context, (*msg).chat_id) {
let mut last_added_location_id: uint32_t = 0i32 as uint32_t; let mut last_added_location_id: uint32_t = 0 as uint32_t;
let kml_file: *mut libc::c_char = dc_get_location_kml( let kml_file: *mut libc::c_char = dc_get_location_kml(
(*msg).context, (*msg).context,
(*msg).chat_id, (*msg).chat_id,
@@ -943,12 +964,12 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
mailmime_add_part(message, multipart); mailmime_add_part(message, multipart);
let p1: *mut libc::c_char; let p1: *mut libc::c_char;
let p2: *mut libc::c_char; let p2: *mut libc::c_char;
if 0 != dc_param_get_int((*(*factory).msg).param, 'c' as i32, 0i32) { if 0 != dc_param_get_int((*(*factory).msg).param, 'c' as i32, 0) {
p1 = dc_stock_str((*factory).context, 24i32) p1 = dc_stock_str((*factory).context, 24)
} else { } else {
p1 = dc_msg_get_summarytext((*factory).msg, 32i32) p1 = dc_msg_get_summarytext((*factory).msg, 32)
} }
p2 = dc_stock_str_repl_string((*factory).context, 32i32, p1); p2 = dc_stock_str_repl_string((*factory).context, 32, p1);
message_text = dc_mprintf(b"%s\r\n\x00" as *const u8 as *const libc::c_char, p2); message_text = dc_mprintf(b"%s\r\n\x00" as *const u8 as *const libc::c_char, p2);
free(p2 as *mut libc::c_void); free(p2 as *mut libc::c_void);
free(p1 as *mut libc::c_void); free(p1 as *mut libc::c_void);
@@ -968,7 +989,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
let mach_mime_part: *mut mailmime = mailmime_new_empty(content_type_0, mime_fields_0); let mach_mime_part: *mut mailmime = mailmime_new_empty(content_type_0, mime_fields_0);
mailmime_set_body_text(mach_mime_part, message_text2, strlen(message_text2)); mailmime_set_body_text(mach_mime_part, message_text2, strlen(message_text2));
mailmime_add_part(multipart, mach_mime_part); mailmime_add_part(multipart, mach_mime_part);
force_plaintext = 2i32; force_plaintext = 2;
current_block = 9952640327414195044; current_block = 9952640327414195044;
} else { } else {
set_error( set_error(
@@ -983,7 +1004,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
if (*factory).loaded as libc::c_uint if (*factory).loaded as libc::c_uint
== DC_MF_MDN_LOADED as libc::c_int as libc::c_uint == DC_MF_MDN_LOADED as libc::c_int as libc::c_uint
{ {
let e: *mut libc::c_char = dc_stock_str((*factory).context, 31i32); let e: *mut libc::c_char = dc_stock_str((*factory).context, 31);
subject_str = subject_str =
dc_mprintf(b"Chat: %s\x00" as *const u8 as *const libc::c_char, e); dc_mprintf(b"Chat: %s\x00" as *const u8 as *const libc::c_char, e);
free(e as *mut libc::c_void); free(e as *mut libc::c_void);
@@ -1019,7 +1040,7 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
0 as *mut mailimf_optional_field, 0 as *mut mailimf_optional_field,
), ),
); );
if force_plaintext != 2i32 { if force_plaintext != 2 {
dc_e2ee_encrypt( dc_e2ee_encrypt(
(*factory).context, (*factory).context,
(*factory).recipients_addr, (*factory).recipients_addr,
@@ -1032,14 +1053,14 @@ pub unsafe fn dc_mimefactory_render(mut factory: *mut dc_mimefactory_t) -> libc:
); );
} }
if 0 != e2ee_helper.encryption_successfull { if 0 != e2ee_helper.encryption_successfull {
(*factory).out_encrypted = 1i32; (*factory).out_encrypted = 1;
if 0 != do_gossip { if 0 != do_gossip {
(*factory).out_gossiped = 1i32 (*factory).out_gossiped = 1
} }
} }
(*factory).out = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char); (*factory).out = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
mailmime_write_mem((*factory).out, &mut col, message); mailmime_write_mem((*factory).out, &mut col, message);
success = 1i32 success = 1
} }
} }
} }
@@ -1063,15 +1084,15 @@ unsafe fn get_subject(
let context = (*chat).context; let context = (*chat).context;
let ret: *mut libc::c_char; let ret: *mut libc::c_char;
let raw_subject: *mut libc::c_char = let 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, 32, context);
let fwd: *const libc::c_char = if 0 != afwd_email { let fwd: *const libc::c_char = if 0 != afwd_email {
b"Fwd: \x00" as *const u8 as *const libc::c_char b"Fwd: \x00" as *const u8 as *const libc::c_char
} else { } else {
b"\x00" as *const u8 as *const libc::c_char b"\x00" as *const u8 as *const libc::c_char
}; };
if dc_param_get_int((*msg).param, 'S' as i32, 0i32) == 6i32 { if dc_param_get_int((*msg).param, 'S' as i32, 0) == 6 {
ret = dc_stock_str(context, 42i32) ret = dc_stock_str(context, 42)
} else if (*chat).type_0 == 120i32 || (*chat).type_0 == 130i32 { } else if (*chat).type_0 == 120 || (*chat).type_0 == 130 {
ret = dc_mprintf( ret = dc_mprintf(
b"Chat: %s: %s%s\x00" as *const u8 as *const libc::c_char, b"Chat: %s: %s%s\x00" as *const u8 as *const libc::c_char,
(*chat).name, (*chat).name,
@@ -1135,7 +1156,7 @@ unsafe fn build_body_file(
let mut filename_to_send: *mut libc::c_char = 0 as *mut libc::c_char; let mut filename_to_send: *mut libc::c_char = 0 as *mut libc::c_char;
let mut filename_encoded: *mut libc::c_char = 0 as *mut libc::c_char; let mut filename_encoded: *mut libc::c_char = 0 as *mut libc::c_char;
if !pathNfilename.is_null() { if !pathNfilename.is_null() {
if (*msg).type_0 == 41i32 { if (*msg).type_0 == 41 {
let ts = chrono::Utc.timestamp((*msg).timestamp_sort as i64, 0); let ts = chrono::Utc.timestamp((*msg).timestamp_sort as i64, 0);
let suffix = if !suffix.is_null() { let suffix = if !suffix.is_null() {
@@ -1147,9 +1168,9 @@ unsafe fn build_body_file(
.format(&format!("voice-message_%Y-%m-%d_%H-%M-%S.{}", suffix)) .format(&format!("voice-message_%Y-%m-%d_%H-%M-%S.{}", suffix))
.to_string(); .to_string();
filename_to_send = strdup(to_cstring(res).as_ptr()); filename_to_send = strdup(to_cstring(res).as_ptr());
} else if (*msg).type_0 == 40i32 { } else if (*msg).type_0 == 40 {
filename_to_send = dc_get_filename(pathNfilename) filename_to_send = dc_get_filename(pathNfilename)
} else if (*msg).type_0 == 20i32 || (*msg).type_0 == 21i32 { } else if (*msg).type_0 == 20 || (*msg).type_0 == 21 {
if base_name.is_null() { if base_name.is_null() {
base_name = b"image\x00" as *const u8 as *const libc::c_char base_name = b"image\x00" as *const u8 as *const libc::c_char
} }
@@ -1162,7 +1183,7 @@ unsafe fn build_body_file(
b"dat\x00" as *const u8 as *const libc::c_char b"dat\x00" as *const u8 as *const libc::c_char
}, },
) )
} else if (*msg).type_0 == 50i32 { } else if (*msg).type_0 == 50 {
filename_to_send = dc_mprintf( filename_to_send = dc_mprintf(
b"video.%s\x00" as *const u8 as *const libc::c_char, b"video.%s\x00" as *const u8 as *const libc::c_char,
if !suffix.is_null() { if !suffix.is_null() {
@@ -1178,14 +1199,14 @@ unsafe fn build_body_file(
if suffix.is_null() { if suffix.is_null() {
mimetype = mimetype =
dc_strdup(b"application/octet-stream\x00" as *const u8 as *const libc::c_char) dc_strdup(b"application/octet-stream\x00" as *const u8 as *const libc::c_char)
} else if strcmp(suffix, b"png\x00" as *const u8 as *const libc::c_char) == 0i32 { } else if strcmp(suffix, b"png\x00" as *const u8 as *const libc::c_char) == 0 {
mimetype = dc_strdup(b"image/png\x00" as *const u8 as *const libc::c_char) mimetype = dc_strdup(b"image/png\x00" as *const u8 as *const libc::c_char)
} else if strcmp(suffix, b"jpg\x00" as *const u8 as *const libc::c_char) == 0i32 } else if strcmp(suffix, b"jpg\x00" as *const u8 as *const libc::c_char) == 0
|| strcmp(suffix, b"jpeg\x00" as *const u8 as *const libc::c_char) == 0i32 || strcmp(suffix, b"jpeg\x00" as *const u8 as *const libc::c_char) == 0
|| strcmp(suffix, b"jpe\x00" as *const u8 as *const libc::c_char) == 0i32 || strcmp(suffix, b"jpe\x00" as *const u8 as *const libc::c_char) == 0
{ {
mimetype = dc_strdup(b"image/jpeg\x00" as *const u8 as *const libc::c_char) mimetype = dc_strdup(b"image/jpeg\x00" as *const u8 as *const libc::c_char)
} else if strcmp(suffix, b"gif\x00" as *const u8 as *const libc::c_char) == 0i32 { } else if strcmp(suffix, b"gif\x00" as *const u8 as *const libc::c_char) == 0 {
mimetype = dc_strdup(b"image/gif\x00" as *const u8 as *const libc::c_char) mimetype = dc_strdup(b"image/gif\x00" as *const u8 as *const libc::c_char)
} else { } else {
mimetype = mimetype =
@@ -1228,7 +1249,7 @@ unsafe fn build_body_file(
0 as *mut libc::c_char, 0 as *mut libc::c_char,
0 as *mut libc::c_char, 0 as *mut libc::c_char,
0 as *mut libc::c_char, 0 as *mut libc::c_char,
0i32 as size_t, 0 as size_t,
mailmime_parameter_new( mailmime_parameter_new(
strdup( strdup(
b"filename*\x00" as *const u8 as *const libc::c_char, b"filename*\x00" as *const u8 as *const libc::c_char,
@@ -1285,12 +1306,12 @@ unsafe fn build_body_file(
******************************************************************************/ ******************************************************************************/
unsafe fn is_file_size_okay(msg: *const dc_msg_t) -> libc::c_int { unsafe fn is_file_size_okay(msg: *const dc_msg_t) -> libc::c_int {
let mut file_size_okay: libc::c_int = 1i32; let mut file_size_okay: libc::c_int = 1;
let pathNfilename: *mut libc::c_char = let pathNfilename: *mut libc::c_char =
dc_param_get((*msg).param, 'f' as i32, 0 as *const libc::c_char); dc_param_get((*msg).param, 'f' as i32, 0 as *const libc::c_char);
let bytes: uint64_t = dc_get_filebytes((*msg).context, pathNfilename); let bytes: uint64_t = dc_get_filebytes((*msg).context, pathNfilename);
if bytes > (49i32 * 1024i32 * 1024i32 / 4i32 * 3i32) as libc::c_ulonglong { if bytes > (49 * 1024 * 1024 / 4 * 3) as libc::c_ulonglong {
file_size_okay = 0i32 file_size_okay = 0;
} }
free(pathNfilename as *mut libc::c_void); free(pathNfilename as *mut libc::c_void);

40
src/dc_mimeparser.rs
View File

@@ -15,7 +15,6 @@ use crate::context::Context;
use crate::dc_contact::*; use crate::dc_contact::*;
use crate::dc_e2ee::*; use crate::dc_e2ee::*;
use crate::dc_location::*; use crate::dc_location::*;
use crate::dc_log::*;
use crate::dc_param::*; use crate::dc_param::*;
use crate::dc_simplify::*; use crate::dc_simplify::*;
use crate::dc_stock::*; use crate::dc_stock::*;
@@ -531,11 +530,9 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
b"rfc822-headers\x00" as *const u8 as *const libc::c_char, b"rfc822-headers\x00" as *const u8 as *const libc::c_char,
) == 0i32 ) == 0i32
{ {
dc_log_info( info!(
(*mimeparser).context, (*mimeparser).context,
0i32, 0, "Protected headers found in text/rfc822-headers attachment: Will be ignored.",
b"Protected headers found in text/rfc822-headers attachment: Will be ignored.\x00"
as *const u8 as *const libc::c_char,
); );
return 0i32; return 0i32;
} }
@@ -549,11 +546,7 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
) != MAILIMF_NO_ERROR as libc::c_int ) != MAILIMF_NO_ERROR as libc::c_int
|| (*mimeparser).header_protected.is_null() || (*mimeparser).header_protected.is_null()
{ {
dc_log_warning( warn!((*mimeparser).context, 0, "Protected headers parsing error.",);
(*mimeparser).context,
0i32,
b"Protected headers parsing error.\x00" as *const u8 as *const libc::c_char,
);
} else { } else {
hash_header( hash_header(
&mut (*mimeparser).header, &mut (*mimeparser).header,
@@ -562,9 +555,11 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
); );
} }
} else { } else {
dc_log_info((*mimeparser).context, 0i32, info!(
b"Protected headers found in MIME header: Will be ignored as we already found an outer one.\x00" (*mimeparser).context,
as *const u8 as *const libc::c_char); 0,
"Protected headers found in MIME header: Will be ignored as we already found an outer one."
);
} }
} }
match (*mime).mm_type { match (*mime).mm_type {
@@ -756,10 +751,11 @@ unsafe fn dc_mimeparser_parse_mime_recursive(
} }
} }
if plain_cnt == 1i32 && html_cnt == 1i32 { if plain_cnt == 1i32 && html_cnt == 1i32 {
dc_log_warning((*mimeparser).context, 0i32, warn!(
b"HACK: multipart/mixed message found with PLAIN and HTML, we\'ll skip the HTML part as this seems to be unwanted.\x00" (*mimeparser).context,
as *const u8 as 0i32,
*const libc::c_char); "HACK: multipart/mixed message found with PLAIN and HTML, we\'ll skip the HTML part as this seems to be unwanted."
);
skip_part = html_part skip_part = html_part
} }
cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first; cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
@@ -1213,14 +1209,12 @@ unsafe fn dc_mimeparser_add_single_part_if_known(
current_block = 17788412896529399552; current_block = 17788412896529399552;
} }
} else { } else {
dc_log_warning( warn!(
mimeparser.context, mimeparser.context,
0i32, 0,
b"Cannot convert %i bytes from \"%s\" to \"utf-8\".\x00" "Cannot convert {} bytes from \"{}\" to \"utf-8\".",
as *const u8
as *const libc::c_char,
decoded_data_bytes as libc::c_int, decoded_data_bytes as libc::c_int,
charset, as_str(charset),
); );
current_block = 17788412896529399552; current_block = 17788412896529399552;
} }

52
src/dc_move.rs
View File

@@ -2,44 +2,40 @@ use crate::constants::*;
use crate::context::*; use crate::context::*;
use crate::dc_job::*; use crate::dc_job::*;
use crate::dc_msg::*; use crate::dc_msg::*;
use crate::dc_sqlite3::*; use crate::sql;
use crate::types::*;
pub unsafe fn dc_do_heuristics_moves( pub unsafe fn dc_do_heuristics_moves(context: &Context, folder: &str, msg_id: u32) {
context: &Context, if sql::get_config_int(context, &context.sql, "mvbox_move", 1) == 0 {
folder: *const libc::c_char, return;
msg_id: uint32_t, }
) {
// for already seen messages, folder may be different from msg->folder if !dc_is_inbox(context, folder) && !dc_is_sentbox(context, folder) {
let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t; return;
let stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; }
if !(dc_sqlite3_get_config_int(
context, let msg = dc_msg_new_load(context, msg_id);
&context.sql, if dc_msg_is_setupmessage(msg) {
b"mvbox_move\x00" as *const u8 as *const libc::c_char,
1i32,
) == 0i32)
{
if !(0 == dc_is_inbox(context, folder) && 0 == dc_is_sentbox(context, folder)) {
msg = dc_msg_new_load(context, msg_id);
if !(0 != dc_msg_is_setupmessage(msg)) {
// do not move setup messages; // do not move setup messages;
// there may be a non-delta device that wants to handle it // there may be a non-delta device that wants to handle it
if 0 != dc_is_mvbox(context, folder) { dc_msg_unref(msg);
return;
}
if dc_is_mvbox(context, folder) {
dc_update_msg_move_state(context, (*msg).rfc724_mid, DC_MOVE_STATE_STAY); dc_update_msg_move_state(context, (*msg).rfc724_mid, DC_MOVE_STATE_STAY);
} else if 0 != (*msg).is_dc_message { }
// 1 = dc message, 2 = reply to dc message
if 0 != (*msg).is_dc_message {
dc_job_add( dc_job_add(
context, context,
200i32, 200,
(*msg).id as libc::c_int, (*msg).id as libc::c_int,
0 as *const libc::c_char, 0 as *const libc::c_char,
0i32, 0,
); );
dc_update_msg_move_state(context, (*msg).rfc724_mid, DC_MOVE_STATE_MOVING); dc_update_msg_move_state(context, (*msg).rfc724_mid, DC_MOVE_STATE_MOVING);
} }
}
}
}
sqlite3_finalize(stmt);
dc_msg_unref(msg); dc_msg_unref(msg);
} }

838
src/dc_msg.rs
View File

File diff suppressed because it is too large Load Diff

8
src/dc_qr.rs
View File

@@ -1,7 +1,6 @@
use crate::context::Context; use crate::context::Context;
use crate::dc_chat::*; use crate::dc_chat::*;
use crate::dc_contact::*; use crate::dc_contact::*;
use crate::dc_log::*;
use crate::dc_lot::*; use crate::dc_lot::*;
use crate::dc_param::*; use crate::dc_param::*;
use crate::dc_strencode::*; use crate::dc_strencode::*;
@@ -38,12 +37,7 @@ pub unsafe fn dc_check_qr(context: &Context, qr: *const libc::c_char) -> *mut dc
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 !qr.is_null() { if !qr.is_null() {
dc_log_info( info!(context, 0, "Scanned QR code: {}", as_str(qr),);
context,
0i32,
b"Scanned QR code: %s\x00" as *const u8 as *const libc::c_char,
qr,
);
/* split parameters from the qr code /* split parameters from the qr code
------------------------------------ */ ------------------------------------ */
if strncasecmp( if strncasecmp(

1162
src/dc_receive_imf.rs
View File

File diff suppressed because it is too large Load Diff

353
src/dc_securejoin.rs
View File

@@ -1,4 +1,5 @@
use mmime::mailimf_types::*; use mmime::mailimf_types::*;
use percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET};
use crate::aheader::EncryptPreference; use crate::aheader::EncryptPreference;
use crate::constants::Event; use crate::constants::Event;
@@ -8,19 +9,18 @@ use crate::dc_chat::*;
use crate::dc_configure::*; use crate::dc_configure::*;
use crate::dc_contact::*; use crate::dc_contact::*;
use crate::dc_e2ee::*; use crate::dc_e2ee::*;
use crate::dc_log::*;
use crate::dc_lot::*; use crate::dc_lot::*;
use crate::dc_mimeparser::*; use crate::dc_mimeparser::*;
use crate::dc_msg::*; use crate::dc_msg::*;
use crate::dc_param::*; use crate::dc_param::*;
use crate::dc_qr::*; use crate::dc_qr::*;
use crate::dc_sqlite3::*;
use crate::dc_stock::*; use crate::dc_stock::*;
use crate::dc_strencode::*; use crate::dc_strencode::*;
use crate::dc_token::*; use crate::dc_token::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::key::*; use crate::key::*;
use crate::peerstate::*; use crate::peerstate::*;
use crate::sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -28,22 +28,18 @@ pub unsafe fn dc_get_securejoin_qr(
context: &Context, context: &Context,
group_chat_id: uint32_t, group_chat_id: uint32_t,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
let current_block: u64;
/* ========================================================= /* =========================================================
==== Alice - the inviter side ==== ==== Alice - the inviter side ====
==== Step 1 in "Setup verified contact" protocol ==== ==== Step 1 in "Setup verified contact" protocol ====
========================================================= */ ========================================================= */
let mut qr: *mut libc::c_char = 0 as *mut libc::c_char;
let self_addr: *mut libc::c_char; let mut fingerprint = 0 as *mut libc::c_char;
let mut self_addr_urlencoded: *mut libc::c_char = 0 as *mut libc::c_char;
let mut self_name: *mut libc::c_char = 0 as *mut libc::c_char;
let mut self_name_urlencoded: *mut libc::c_char = 0 as *mut libc::c_char;
let mut fingerprint: *mut libc::c_char = 0 as *mut libc::c_char;
let mut invitenumber: *mut libc::c_char; let mut invitenumber: *mut libc::c_char;
let mut auth: *mut libc::c_char; let mut auth: *mut libc::c_char;
let mut chat: *mut Chat = 0 as *mut Chat; let mut chat = 0 as *mut Chat;
let mut group_name: *mut libc::c_char = 0 as *mut libc::c_char; let mut group_name = 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 = 0 as *mut libc::c_char;
let mut qr = None;
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);
@@ -56,111 +52,83 @@ pub unsafe fn dc_get_securejoin_qr(
auth = dc_create_id(); auth = dc_create_id();
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( let self_addr = sql::get_config(context, &context.sql, "configured_addr", None);
context,
&context.sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
0 as *const libc::c_char,
);
if self_addr.is_null() {
dc_log_error(
context,
0i32,
b"Not configured, cannot generate QR code.\x00" as *const u8 as *const libc::c_char,
);
} else {
self_name = dc_sqlite3_get_config(
context,
&context.sql,
b"displayname\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
fingerprint = get_self_fingerprint(context);
if !fingerprint.is_null() {
self_addr_urlencoded = dc_urlencode(self_addr);
self_name_urlencoded = dc_urlencode(self_name);
if 0 != group_chat_id {
chat = dc_get_chat(context, group_chat_id);
if chat.is_null() {
dc_log_error(
context,
0i32,
b"Cannot get QR-code for chat-id %i\x00" as *const u8
as *const libc::c_char,
group_chat_id,
);
current_block = 9531737720721467826;
} else {
group_name = dc_chat_get_name(chat);
group_name_urlencoded = dc_urlencode(group_name);
qr = dc_mprintf(
b"OPENPGP4FPR:%s#a=%s&g=%s&x=%s&i=%s&s=%s\x00" as *const u8
as *const libc::c_char,
fingerprint,
self_addr_urlencoded,
group_name_urlencoded,
(*chat).grpid,
invitenumber,
auth,
);
current_block = 1118134448028020070;
}
} else {
qr = dc_mprintf(
b"OPENPGP4FPR:%s#a=%s&n=%s&i=%s&s=%s\x00" as *const u8 as *const libc::c_char,
fingerprint,
self_addr_urlencoded,
self_name_urlencoded,
invitenumber,
auth,
);
current_block = 1118134448028020070;
}
match current_block {
9531737720721467826 => {}
_ => {
dc_log_info(
context,
0i32,
b"Generated QR code: %s\x00" as *const u8 as *const libc::c_char,
qr,
);
}
}
}
}
free(self_addr_urlencoded as *mut libc::c_void); let cleanup = |fingerprint, chat, group_name, group_name_urlencoded| {
free(self_addr as *mut libc::c_void);
free(self_name as *mut libc::c_void);
free(self_name_urlencoded as *mut libc::c_void);
free(fingerprint as *mut libc::c_void); free(fingerprint as *mut libc::c_void);
free(invitenumber as *mut libc::c_void); free(invitenumber as *mut libc::c_void);
free(auth as *mut libc::c_void); free(auth as *mut libc::c_void);
dc_chat_unref(chat); dc_chat_unref(chat);
free(group_name as *mut libc::c_void); free(group_name as *mut libc::c_void);
free(group_name_urlencoded as *mut libc::c_void); free(group_name_urlencoded as *mut libc::c_void);
return if !qr.is_null() {
qr
} else {
dc_strdup(0 as *const libc::c_char)
};
}
unsafe fn get_self_fingerprint(context: &Context) -> *mut libc::c_char { if let Some(qr) = qr {
let self_addr = dc_sqlite3_get_config( strdup(to_cstring(qr).as_ptr())
context, } else {
&context.sql, std::ptr::null_mut()
b"configured_addr\x00" as *const u8 as *const libc::c_char, }
0 as *const libc::c_char, };
);
if self_addr.is_null() { if self_addr.is_none() {
return std::ptr::null_mut(); error!(context, 0, "Not configured, cannot generate QR code.",);
return cleanup(fingerprint, chat, group_name, group_name_urlencoded);
} }
let self_addr = self_addr.unwrap();
let self_name = sql::get_config(context, &context.sql, "displayname", Some("")).unwrap();
fingerprint = get_self_fingerprint(context);
if fingerprint.is_null() {
return cleanup(fingerprint, chat, group_name, group_name_urlencoded);
}
let self_addr_urlencoded = utf8_percent_encode(&self_addr, DEFAULT_ENCODE_SET).to_string();
let self_name_urlencoded = utf8_percent_encode(&self_name, DEFAULT_ENCODE_SET).to_string();
qr = if 0 != group_chat_id {
chat = dc_get_chat(context, group_chat_id);
if chat.is_null() {
error!(
context,
0, "Cannot get QR-code for chat-id {}", group_chat_id,
);
return cleanup(fingerprint, chat, group_name, group_name_urlencoded);
}
group_name = dc_chat_get_name(chat);
group_name_urlencoded = dc_urlencode(group_name);
Some(format!(
"OPENPGP4FPR:{}#a={}&g={}&x={}&i={}&s={}",
as_str(fingerprint),
self_addr_urlencoded,
as_str(group_name_urlencoded),
as_str((*chat).grpid),
as_str(invitenumber),
as_str(auth),
))
} else {
Some(format!(
"OPENPGP4FPR:{}#a={}&n={}&i={}&s={}",
as_str(fingerprint),
self_addr_urlencoded,
self_name_urlencoded,
as_str(invitenumber),
as_str(auth),
))
};
info!(context, 0, "Generated QR code: {}", qr.as_ref().unwrap());
cleanup(fingerprint, chat, group_name, group_name_urlencoded)
}
fn get_self_fingerprint(context: &Context) -> *mut libc::c_char {
if let Some(self_addr) = sql::get_config(context, &context.sql, "configured_addr", None) {
if let Some(key) = Key::from_self_public(context, self_addr, &context.sql) { if let Some(key) = Key::from_self_public(context, self_addr, &context.sql) {
return key.fingerprint_c(); return key.fingerprint_c();
} }
}
std::ptr::null_mut() std::ptr::null_mut()
} }
@@ -175,29 +143,17 @@ pub unsafe fn dc_join_securejoin(context: &Context, qr: *const libc::c_char) ->
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;
dc_log_info( info!(context, 0, "Requesting secure-join ...",);
context,
0i32,
b"Requesting secure-join ...\x00" as *const u8 as *const libc::c_char,
);
dc_ensure_secret_key_exists(context); dc_ensure_secret_key_exists(context);
ongoing_allocated = dc_alloc_ongoing(context); ongoing_allocated = dc_alloc_ongoing(context);
if !(ongoing_allocated == 0i32) { if !(ongoing_allocated == 0i32) {
qr_scan = dc_check_qr(context, qr); qr_scan = dc_check_qr(context, qr);
if qr_scan.is_null() || (*qr_scan).state != 200i32 && (*qr_scan).state != 202i32 { if qr_scan.is_null() || (*qr_scan).state != 200i32 && (*qr_scan).state != 202i32 {
dc_log_error( error!(context, 0, "Unknown QR code.",);
context,
0i32,
b"Unknown QR code.\x00" as *const u8 as *const libc::c_char,
);
} else { } else {
contact_chat_id = dc_create_chat_by_contact_id(context, (*qr_scan).id); contact_chat_id = dc_create_chat_by_contact_id(context, (*qr_scan).id);
if contact_chat_id == 0i32 as libc::c_uint { if contact_chat_id == 0i32 as libc::c_uint {
dc_log_error( error!(context, 0, "Unknown contact.",);
context,
0i32,
b"Unknown contact.\x00" as *const u8 as *const libc::c_char,
);
} else if !(context } else if !(context
.running_state .running_state
.clone() .clone()
@@ -214,11 +170,7 @@ pub unsafe fn dc_join_securejoin(context: &Context, qr: *const libc::c_char) ->
} }
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( info!(context, 0, "Taking protocol shortcut.");
context,
0i32,
b"Taking protocol shortcut.\x00" as *const u8 as *const libc::c_char,
);
context.bob.clone().write().unwrap().expects = 6; context.bob.clone().write().unwrap().expects = 6;
context.call_cb( context.call_cb(
Event::SECUREJOIN_JOINER_PROGRESS, Event::SECUREJOIN_JOINER_PROGRESS,
@@ -403,12 +355,11 @@ pub unsafe fn dc_handle_securejoin_handshake(
if !(contact_id <= 9i32 as libc::c_uint) { if !(contact_id <= 9i32 as libc::c_uint) {
step = lookup_field(mimeparser, "Secure-Join"); step = lookup_field(mimeparser, "Secure-Join");
if !step.is_null() { if !step.is_null() {
dc_log_info( info!(
context, context,
0i32, 0,
b">>>>>>>>>>>>>>>>>>>>>>>>> secure-join message \'%s\' received\x00" as *const u8 ">>>>>>>>>>>>>>>>>>>>>>>>> secure-join message \'{}\' received",
as *const libc::c_char, as_str(step),
step,
); );
join_vg = (strncmp(step, b"vg-\x00" as *const u8 as *const libc::c_char, 3) == 0) join_vg = (strncmp(step, b"vg-\x00" as *const u8 as *const libc::c_char, 3) == 0)
as libc::c_int; as libc::c_int;
@@ -439,11 +390,12 @@ pub unsafe fn dc_handle_securejoin_handshake(
if invitenumber.is_null() { if invitenumber.is_null() {
warn!(context, 0, "Secure-join denied (invitenumber missing).",); warn!(context, 0, "Secure-join denied (invitenumber missing).",);
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else if dc_token_exists(context, DC_TOKEN_INVITENUMBER, invitenumber) == 0i32 { } else if !dc_token_exists(context, DC_TOKEN_INVITENUMBER, invitenumber) {
warn!(context, 0, "Secure-join denied (bad invitenumber).",); warn!(context, 0, "Secure-join denied (bad invitenumber).",);
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
info!(context, 0, "Secure-join requested.",); info!(context, 0, "Secure-join requested.",);
context.call_cb( context.call_cb(
Event::SECUREJOIN_INVITER_PROGRESS, Event::SECUREJOIN_INVITER_PROGRESS,
contact_id as uintptr_t, contact_id as uintptr_t,
@@ -480,12 +432,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
}; };
if cond { if cond {
dc_log_warning( warn!(context, 0, "auth-required message out of sync.",);
context,
0i32,
b"auth-required message out of sync.\x00" as *const u8
as *const libc::c_char,
);
// 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 {
@@ -525,11 +472,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
end_bobs_joining(context, 0i32); end_bobs_joining(context, 0i32);
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
dc_log_info( info!(context, 0, "Fingerprint verified.",);
context,
0i32,
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.call_cb( context.call_cb(
Event::SECUREJOIN_JOINER_PROGRESS, Event::SECUREJOIN_JOINER_PROGRESS,
@@ -593,11 +536,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
); );
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
dc_log_info( info!(context, 0, "Fingerprint verified.",);
context,
0i32,
b"Fingerprint verified.\x00" as *const u8 as *const libc::c_char,
);
// verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code // verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code
let auth_0: *const libc::c_char; let auth_0: *const libc::c_char;
auth_0 = lookup_field(mimeparser, "Secure-Join-Auth"); auth_0 = lookup_field(mimeparser, "Secure-Join-Auth");
@@ -608,7 +547,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
b"Auth not provided.\x00" as *const u8 as *const libc::c_char, b"Auth not provided.\x00" as *const u8 as *const libc::c_char,
); );
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else if dc_token_exists(context, DC_TOKEN_AUTH, auth_0) == 0i32 { } else if !dc_token_exists(context, DC_TOKEN_AUTH, auth_0) {
could_not_establish_secure_connection( could_not_establish_secure_connection(
context, context,
contact_chat_id, contact_chat_id,
@@ -625,11 +564,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
dc_scaleup_contact_origin(context, contact_id, 0x1000000i32); dc_scaleup_contact_origin(context, contact_id, 0x1000000i32);
dc_log_info( info!(context, 0, "Auth verified.",);
context,
0i32,
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.call_cb( context.call_cb(
Event::CONTACTS_CHANGED, Event::CONTACTS_CHANGED,
@@ -650,12 +585,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
0 as *mut libc::c_int, 0 as *mut libc::c_int,
); );
if group_chat_id == 0i32 as libc::c_uint { if group_chat_id == 0i32 as libc::c_uint {
dc_log_error( error!(context, 0, "Chat {} not found.", as_str(grpid),);
context,
0i32,
b"Chat %s not found.\x00" as *const u8 as *const libc::c_char,
grpid,
);
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
dc_add_contact_to_chat_ex( dc_add_contact_to_chat_ex(
@@ -697,12 +627,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
ret = 0x1i32 ret = 0x1i32
} }
if context.bob.clone().read().unwrap().expects != 6 { if context.bob.clone().read().unwrap().expects != 6 {
dc_log_info( info!(context, 0, "Message belongs to a different handshake.",);
context,
0i32,
b"Message belongs to a different handshake.\x00" as *const u8
as *const libc::c_char,
);
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
let cond = { let cond = {
@@ -710,11 +635,9 @@ pub unsafe fn dc_handle_securejoin_handshake(
scan.is_null() || 0 != join_vg && (*scan).state != 202 scan.is_null() || 0 != join_vg && (*scan).state != 202
}; };
if cond { if cond {
dc_log_warning( warn!(
context, context,
0i32, 0, "Message out of sync or belongs to a different handshake.",
b"Message out of sync or belongs to a different handshake.\x00"
as *const u8 as *const libc::c_char,
); );
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
@@ -778,10 +701,11 @@ pub unsafe fn dc_handle_securejoin_handshake(
context, context,
lookup_field(mimeparser, "Chat-Group-Member-Added"), lookup_field(mimeparser, "Chat-Group-Member-Added"),
) { ) {
dc_log_info(context, 0i32, info!(
b"Message belongs to a different handshake (scaled up contact anyway to allow creation of group).\x00" context,
as *const u8 as 0,
*const libc::c_char); "Message belongs to a different handshake (scaled up contact anyway to allow creation of group)."
);
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
current_block = 9180031981464905198; current_block = 9180031981464905198;
@@ -825,12 +749,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
============================================================ */ ============================================================ */
contact = dc_get_contact(context, contact_id); contact = dc_get_contact(context, contact_id);
if contact.is_null() || 0 == dc_contact_is_verified(contact) { if contact.is_null() || 0 == dc_contact_is_verified(contact) {
dc_log_warning( warn!(context, 0, "vg-member-added-received invalid.",);
context,
0i32,
b"vg-member-added-received invalid.\x00" as *const u8
as *const libc::c_char,
);
current_block = 4378276786830486580; current_block = 4378276786830486580;
} else { } else {
context.call_cb( context.call_cb(
@@ -928,13 +847,7 @@ unsafe fn could_not_establish_secure_connection(
}, },
); );
dc_add_device_msg(context, contact_chat_id, msg); dc_add_device_msg(context, contact_chat_id, msg);
dc_log_error( error!(context, 0, "{} ({})", as_str(msg), to_string(details),);
context,
0i32,
b"%s (%s)\x00" as *const u8 as *const libc::c_char,
msg,
details,
);
free(msg as *mut libc::c_void); free(msg as *mut libc::c_void);
dc_contact_unref(contact); dc_contact_unref(contact);
} }
@@ -969,27 +882,15 @@ unsafe fn encrypted_and_signed(
expected_fingerprint: *const libc::c_char, expected_fingerprint: *const libc::c_char,
) -> libc::c_int { ) -> libc::c_int {
if 0 == mimeparser.e2ee_helper.encrypted { if 0 == mimeparser.e2ee_helper.encrypted {
dc_log_warning( warn!(mimeparser.context, 0, "Message not encrypted.",);
mimeparser.context,
0i32,
b"Message not encrypted.\x00" as *const u8 as *const libc::c_char,
);
return 0i32; return 0i32;
} }
if mimeparser.e2ee_helper.signatures.len() <= 0 { if mimeparser.e2ee_helper.signatures.len() <= 0 {
dc_log_warning( warn!(mimeparser.context, 0, "Message not signed.",);
mimeparser.context,
0i32,
b"Message not signed.\x00" as *const u8 as *const libc::c_char,
);
return 0i32; return 0i32;
} }
if expected_fingerprint.is_null() { if expected_fingerprint.is_null() {
dc_log_warning( warn!(mimeparser.context, 0, "Fingerprint for comparison missing.",);
mimeparser.context,
0i32,
b"Fingerprint for comparison missing.\x00" as *const u8 as *const libc::c_char,
);
return 0i32; return 0i32;
} }
if !mimeparser if !mimeparser
@@ -997,23 +898,20 @@ unsafe fn encrypted_and_signed(
.signatures .signatures
.contains(as_str(expected_fingerprint)) .contains(as_str(expected_fingerprint))
{ {
dc_log_warning( warn!(
mimeparser.context, mimeparser.context,
0i32, 0,
b"Message does not match expected fingerprint %s.\x00" as *const u8 "Message does not match expected fingerprint {}.",
as *const libc::c_char, as_str(expected_fingerprint),
expected_fingerprint,
); );
return 0i32; return 0;
} }
1 1
} }
pub unsafe fn dc_handle_degrade_event(context: &Context, peerstate: &Peerstate) { pub unsafe fn dc_handle_degrade_event(context: &Context, peerstate: &Peerstate) {
let stmt; let mut contact_chat_id = 0;
let contact_id: uint32_t;
let mut contact_chat_id: uint32_t = 0i32 as uint32_t;
// - 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
@@ -1021,38 +919,35 @@ pub unsafe fn dc_handle_degrade_event(context: &Context, peerstate: &Peerstate)
// with things they cannot fix, so the user is just kicked from the verified group // with things they cannot fix, so the user is just kicked from the verified group
// (and he will know this and can fix this) // (and he will know this and can fix this)
if Some(DegradeEvent::FingerprintChanged) == peerstate.degrade_event { if Some(DegradeEvent::FingerprintChanged) == peerstate.degrade_event {
stmt = dc_sqlite3_prepare( let contact_id: i32 = sql::query_row(
context, context,
&context.sql, &context.sql,
b"SELECT id FROM contacts WHERE addr=?;\x00" as *const u8 as *const libc::c_char, "SELECT id FROM contacts WHERE addr=?;",
); params![&peerstate.addr],
let c_addr = peerstate.addr.as_ref().map(to_cstring).unwrap_or_default(); 0,
)
let c_addr_ptr = if peerstate.addr.is_some() { .unwrap_or_default();
c_addr.as_ptr() if contact_id > 0 {
} else {
std::ptr::null()
};
sqlite3_bind_text(stmt, 1i32, c_addr_ptr, -1i32, None);
sqlite3_step(stmt);
contact_id = sqlite3_column_int(stmt, 0i32) as uint32_t;
sqlite3_finalize(stmt);
if !(contact_id == 0i32 as libc::c_uint) {
dc_create_or_lookup_nchat_by_contact_id( dc_create_or_lookup_nchat_by_contact_id(
context, context,
contact_id, contact_id as u32,
2i32, 2,
&mut contact_chat_id, &mut contact_chat_id,
0 as *mut libc::c_int, 0 as *mut libc::c_int,
); );
let msg = dc_stock_str_repl_string(context, 37i32, c_addr_ptr); let c_addr = peerstate.addr.as_ref().map(to_cstring).unwrap_or_default();
let c_addr_ptr = if peerstate.addr.is_some() {
c_addr.as_ptr()
} else {
std::ptr::null_mut()
};
let msg = dc_stock_str_repl_string(context, 37, c_addr_ptr);
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.call_cb( context.call_cb(
Event::CHAT_MODIFIED, Event::CHAT_MODIFIED,
contact_chat_id as uintptr_t, contact_chat_id as uintptr_t,
0i32 as uintptr_t, 0 as uintptr_t,
); );
} }
} }

1605
src/dc_sqlite3.rs
View File

File diff suppressed because it is too large Load Diff

89
src/dc_token.rs
View File

@@ -1,76 +1,65 @@
use crate::context::Context; use crate::context::Context;
use crate::dc_sqlite3::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::types::*; use crate::sql;
use crate::x::strdup;
// Token namespaces // Token namespaces
pub type dc_tokennamespc_t = libc::c_uint; pub type dc_tokennamespc_t = usize;
pub const DC_TOKEN_AUTH: dc_tokennamespc_t = 110; pub const DC_TOKEN_AUTH: dc_tokennamespc_t = 110;
pub const DC_TOKEN_INVITENUMBER: dc_tokennamespc_t = 100; pub const DC_TOKEN_INVITENUMBER: dc_tokennamespc_t = 100;
// Functions to read/write token from/to the database. A token is any string associated with a key. // Functions to read/write token from/to the database. A token is any string associated with a key.
pub unsafe fn dc_token_save(
pub fn dc_token_save(
context: &Context, context: &Context,
namespc: dc_tokennamespc_t, namespc: dc_tokennamespc_t,
foreign_id: uint32_t, foreign_id: u32,
token: *const libc::c_char, token: *const libc::c_char,
) { ) -> bool {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; if token.is_null() {
if !token.is_null() { return false;
}
// foreign_id may be 0 // foreign_id may be 0
stmt = dc_sqlite3_prepare( sql::execute(
context, context,
&context.sql, &context.sql,
b"INSERT INTO tokens (namespc, foreign_id, token, timestamp) VALUES (?, ?, ?, ?);\x00" "INSERT INTO tokens (namespc, foreign_id, token, timestamp) VALUES (?, ?, ?, ?);",
as *const u8 as *const libc::c_char, params![namespc as i32, foreign_id as i32, as_str(token), time()],
); )
sqlite3_bind_int(stmt, 1i32, namespc as libc::c_int);
sqlite3_bind_int(stmt, 2i32, foreign_id as libc::c_int);
sqlite3_bind_text(stmt, 3i32, token, -1i32, None);
sqlite3_bind_int64(stmt, 4i32, time() as sqlite3_int64);
sqlite3_step(stmt);
}
sqlite3_finalize(stmt);
} }
pub unsafe fn dc_token_lookup(
pub fn dc_token_lookup(
context: &Context, context: &Context,
namespc: dc_tokennamespc_t, namespc: dc_tokennamespc_t,
foreign_id: uint32_t, foreign_id: u32,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
let token: *mut libc::c_char; if let Some(token) = sql::query_row::<_, String>(
let stmt: *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
context, context,
&context.sql, &context.sql,
b"SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;\x00" as *const u8 "SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;",
as *const libc::c_char, params![namespc as i32, foreign_id as i32],
); 0,
sqlite3_bind_int(stmt, 1i32, namespc as libc::c_int); ) {
sqlite3_bind_int(stmt, 2i32, foreign_id as libc::c_int); unsafe { strdup(to_cstring(token).as_ptr()) }
sqlite3_step(stmt); } else {
token = dc_strdup_keep_null(sqlite3_column_text(stmt, 0i32) as *mut libc::c_char); std::ptr::null_mut()
}
sqlite3_finalize(stmt);
token
} }
pub unsafe fn dc_token_exists( pub fn dc_token_exists(
context: &Context, context: &Context,
namespc: dc_tokennamespc_t, namespc: dc_tokennamespc_t,
token: *const libc::c_char, token: *const libc::c_char,
) -> libc::c_int { ) -> bool {
let mut exists: libc::c_int = 0i32; if token.is_null() {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt; return false;
if !token.is_null() {
stmt = dc_sqlite3_prepare(
context,
&context.sql,
b"SELECT id FROM tokens WHERE namespc=? AND token=?;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, namespc as libc::c_int);
sqlite3_bind_text(stmt, 2i32, token, -1i32, None);
exists = (sqlite3_step(stmt) != 0i32) as libc::c_int
} }
sqlite3_finalize(stmt);
return exists; context
.sql
.exists(
"SELECT id FROM tokens WHERE namespc=? AND token=?;",
params![namespc as i32, as_str(token)],
)
.unwrap_or_default()
} }

219
src/dc_tools.rs
View File

@@ -1,3 +1,4 @@
use std::borrow::Cow;
use std::fs; use std::fs;
use std::time::SystemTime; use std::time::SystemTime;
@@ -7,10 +8,11 @@ use rand::{thread_rng, Rng};
use crate::context::Context; use crate::context::Context;
use crate::dc_array::*; use crate::dc_array::*;
use crate::dc_log::*;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
const ELLIPSE: &'static str = "[...]";
/* Some tools and enhancements to the used libraries, there should be /* Some tools and enhancements to the used libraries, there should be
no references to Context and other "larger" classes here. */ no references to Context and other "larger" classes here. */
// for carray etc. // for carray etc.
@@ -343,25 +345,16 @@ pub unsafe fn dc_utf8_strlen(s: *const libc::c_char) -> size_t {
j j
} }
pub unsafe fn dc_truncate_str(buf: *mut libc::c_char, approx_chars: libc::c_int) { pub fn dc_truncate_str(buf: &str, approx_chars: usize) -> Cow<str> {
if approx_chars > 0 if approx_chars > 0 && buf.len() > approx_chars + ELLIPSE.len() {
&& strlen(buf) if let Some(index) = buf[..approx_chars].rfind(|c| c == ' ' || c == '\n') {
> approx_chars.wrapping_add( Cow::Owned(format!("{}{}", &buf[..index + 1], ELLIPSE))
strlen(b"[...]\x00" as *const u8 as *const libc::c_char) as libc::c_int } else {
) as usize Cow::Owned(format!("{}{}", &buf[..approx_chars], ELLIPSE))
{
let mut p: *mut libc::c_char = &mut *buf.offset(approx_chars as isize) as *mut libc::c_char;
*p = 0i32 as libc::c_char;
if !strchr(buf, ' ' as i32).is_null() {
while *p.offset(-1i32 as isize) as libc::c_int != ' ' as i32
&& *p.offset(-1i32 as isize) as libc::c_int != '\n' as i32
{
p = p.offset(-1isize);
*p = 0i32 as libc::c_char
} }
} else {
Cow::Borrowed(buf)
} }
strcat(p, b"[...]\x00" as *const u8 as *const libc::c_char);
};
} }
pub unsafe fn dc_truncate_n_unwrap_str( pub unsafe fn dc_truncate_n_unwrap_str(
@@ -675,12 +668,15 @@ pub unsafe fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> i64 {
/* the return value must be free()'d */ /* the return value must be free()'d */
pub unsafe fn dc_timestamp_to_str(wanted: i64) -> *mut libc::c_char { pub unsafe fn dc_timestamp_to_str(wanted: i64) -> *mut libc::c_char {
let ts = chrono::Utc.timestamp(wanted, 0); let res = dc_timestamp_to_str_safe(wanted);
let res = ts.format("%Y.%m.%d %H:%M:%S").to_string();
strdup(to_cstring(res).as_ptr()) strdup(to_cstring(res).as_ptr())
} }
pub fn dc_timestamp_to_str_safe(wanted: i64) -> String {
let ts = chrono::Utc.timestamp(wanted, 0);
ts.format("%Y.%m.%d %H:%M:%S").to_string()
}
pub fn dc_gm2local_offset() -> i64 { pub fn dc_gm2local_offset() -> i64 {
let lt = Local::now(); let lt = Local::now();
((lt.offset().local_minus_utc() / (60 * 60)) * 100) as i64 ((lt.offset().local_minus_utc() / (60 * 60)) * 100) as i64
@@ -905,16 +901,23 @@ pub unsafe fn dc_extract_grpid_from_rfc724_mid_list(list: *const clist) -> *mut
/* file tools */ /* file tools */
pub unsafe fn dc_ensure_no_slash(pathNfilename: *mut libc::c_char) { pub unsafe fn dc_ensure_no_slash(pathNfilename: *mut libc::c_char) {
let path_len: libc::c_int = strlen(pathNfilename) as libc::c_int; let path_len = strlen(pathNfilename);
if path_len > 0i32 { if path_len > 0 {
if *pathNfilename.offset((path_len - 1i32) as isize) as libc::c_int == '/' as i32 if *pathNfilename.offset((path_len - 1) as isize) as libc::c_int == '/' as i32
|| *pathNfilename.offset((path_len - 1i32) as isize) as libc::c_int == '\\' as i32 || *pathNfilename.offset((path_len - 1) as isize) as libc::c_int == '\\' as i32
{ {
*pathNfilename.offset((path_len - 1i32) as isize) = 0i32 as libc::c_char *pathNfilename.offset((path_len - 1) as isize) = 0 as libc::c_char
} }
}; };
} }
pub fn dc_ensure_no_slash_safe(path: &str) -> &str {
if path.ends_with('/') || path.ends_with('\\') {
return &path[..path.len() - 1];
}
path
}
pub unsafe fn dc_validate_filename(filename: *mut libc::c_char) { pub unsafe fn dc_validate_filename(filename: *mut libc::c_char) {
/* function modifies the given buffer and replaces all characters not valid in filenames by a "-" */ /* function modifies the given buffer and replaces all characters not valid in filenames by a "-" */
let mut p1: *mut libc::c_char = filename; let mut p1: *mut libc::c_char = filename;
@@ -1169,12 +1172,7 @@ pub unsafe fn dc_delete_file(context: &Context, pathNfilename: *const libc::c_ch
success = 1; success = 1;
} }
Err(_err) => { Err(_err) => {
dc_log_warning( warn!(context, 0, "Cannot delete \"{}\".", as_str(pathNfilename),);
context,
0i32,
b"Cannot delete \"%s\".\x00" as *const u8 as *const libc::c_char,
pathNfilename,
);
} }
} }
@@ -1204,13 +1202,7 @@ pub unsafe fn dc_copy_file(
success = 1; success = 1;
} }
Err(_) => { Err(_) => {
dc_log_error( error!(context, 0, "Cannot copy \"{}\" to \"{}\".", src_p, dest_p,);
context,
0,
b"Cannot copy \"%s\" to \"%s\".\x00" as *const u8 as *const libc::c_char,
src,
dest,
);
} }
} }
@@ -1233,11 +1225,11 @@ pub unsafe fn dc_create_folder(
success = 1; success = 1;
} }
Err(_err) => { Err(_err) => {
dc_log_warning( warn!(
context, context,
0i32, 0,
b"Cannot create directory \"%s\".\x00" as *const u8 as *const libc::c_char, "Cannot create directory \"{}\".",
pathNfilename, as_str(pathNfilename),
); );
} }
} }
@@ -1256,37 +1248,34 @@ pub unsafe fn dc_write_file(
buf: *const libc::c_void, buf: *const libc::c_void,
buf_bytes: size_t, buf_bytes: size_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success = 0;
let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
if pathNfilename_abs.is_null() {
return 0;
}
let p = std::ffi::CStr::from_ptr(pathNfilename_abs)
.to_str()
.unwrap();
let bytes = std::slice::from_raw_parts(buf as *const u8, buf_bytes); let bytes = std::slice::from_raw_parts(buf as *const u8, buf_bytes);
match fs::write(p, bytes) { dc_write_file_safe(context, as_str(pathNfilename), bytes) as libc::c_int
Ok(_) => { }
info!(context, 0, "wrote file {}", as_str(pathNfilename));
success = 1; pub fn dc_write_file_safe(context: &Context, pathNfilename: impl AsRef<str>, buf: &[u8]) -> bool {
let pathNfilename_abs =
unsafe { dc_get_abs_path(context, to_cstring(pathNfilename.as_ref()).as_ptr()) };
if pathNfilename_abs.is_null() {
return false;
} }
Err(_err) => {
let p = as_str(pathNfilename_abs);
let success = if let Err(_err) = fs::write(p, buf) {
warn!( warn!(
context, context,
0, 0,
"Cannot write {} bytes to \"{}\".", "Cannot write {} bytes to \"{}\".",
buf_bytes, buf.len(),
as_str(pathNfilename), pathNfilename.as_ref(),
); );
} false
} } else {
true
};
free(pathNfilename_abs as *mut libc::c_void); unsafe { free(pathNfilename_abs as *mut libc::c_void) };
success success
} }
@@ -1296,44 +1285,43 @@ pub unsafe fn dc_read_file(
buf: *mut *mut libc::c_void, buf: *mut *mut libc::c_void,
buf_bytes: *mut size_t, buf_bytes: *mut size_t,
) -> libc::c_int { ) -> libc::c_int {
let mut success = 0; if pathNfilename.is_null() {
if pathNfilename.is_null() || buf.is_null() || buf_bytes.is_null() {
return 0; return 0;
} }
if let Some(mut bytes) = dc_read_file_safe(context, as_str(pathNfilename)) {
*buf = 0 as *mut libc::c_void;
*buf_bytes = 0i32 as size_t;
let pathNfilename_abs = dc_get_abs_path(context, pathNfilename);
if pathNfilename_abs.is_null() {
return 0;
}
let p = std::ffi::CStr::from_ptr(pathNfilename_abs)
.to_str()
.unwrap();
match fs::read(p) {
Ok(mut bytes) => {
*buf = &mut bytes[..] as *mut _ as *mut libc::c_void; *buf = &mut bytes[..] as *mut _ as *mut libc::c_void;
*buf_bytes = bytes.len(); *buf_bytes = bytes.len();
std::mem::forget(bytes); std::mem::forget(bytes);
1
success = 1; } else {
0
} }
}
pub fn dc_read_file_safe(context: &Context, pathNfilename: impl AsRef<str>) -> Option<Vec<u8>> {
let pathNfilename_abs =
unsafe { dc_get_abs_path(context, to_cstring(pathNfilename.as_ref()).as_ptr()) };
if pathNfilename_abs.is_null() {
return None;
}
let p = as_str(pathNfilename_abs);
let res = match fs::read(p) {
Ok(bytes) => Some(bytes),
Err(_err) => { Err(_err) => {
dc_log_warning( warn!(
context, context,
0, 0,
b"Cannot read \"%s\" or file is empty.\x00" as *const u8 as *const libc::c_char, "Cannot read \"{}\" or file is empty.",
pathNfilename, pathNfilename.as_ref(),
); );
None
} }
} };
free(pathNfilename_abs as *mut libc::c_void); unsafe { free(pathNfilename_abs as *mut libc::c_void) };
success
res
} }
pub unsafe fn dc_get_fine_pathNfilename( pub unsafe fn dc_get_fine_pathNfilename(
@@ -1706,61 +1694,30 @@ mod tests {
#[test] #[test]
fn test_dc_str_truncate_1() { fn test_dc_str_truncate_1() {
unsafe { let s = "this is a little test string";
let str: *mut libc::c_char = assert_eq!(dc_truncate_str(s, 16), "this is a [...]");
strdup(b"this is a little test string\x00" as *const u8 as *const libc::c_char);
dc_truncate_str(str, 16);
assert_eq!(
CStr::from_ptr(str as *const libc::c_char).to_str().unwrap(),
"this is a [...]"
);
free(str as *mut libc::c_void);
}
} }
#[test] #[test]
fn test_dc_str_truncate_2() { fn test_dc_str_truncate_2() {
unsafe { assert_eq!(dc_truncate_str("1234", 2), "1234");
let str: *mut libc::c_char = strdup(b"1234\x00" as *const u8 as *const libc::c_char);
dc_truncate_str(str, 2);
assert_eq!(
CStr::from_ptr(str as *const libc::c_char).to_str().unwrap(),
"1234"
);
free(str as *mut libc::c_void);
}
} }
#[test] // This test seems wrong
fn test_dc_str_truncate_3() { // #[test]
unsafe { // fn test_dc_str_truncate_3() {
let str: *mut libc::c_char = strdup(b"1234567\x00" as *const u8 as *const libc::c_char); // assert_eq!(dc_truncate_str("1234567", 3), "1[...]");
dc_truncate_str(str, 1); // }
assert_eq!(
CStr::from_ptr(str as *const libc::c_char).to_str().unwrap(),
"1[...]"
);
free(str as *mut libc::c_void);
}
}
#[test] #[test]
fn test_dc_str_truncate_4() { fn test_dc_str_truncate_4() {
unsafe { assert_eq!(dc_truncate_str("123456", 4), "123456");
let str: *mut libc::c_char = strdup(b"123456\x00" as *const u8 as *const libc::c_char);
dc_truncate_str(str, 4);
assert_eq!(
CStr::from_ptr(str as *const libc::c_char).to_str().unwrap(),
"123456"
);
free(str as *mut libc::c_void);
}
} }
#[test] #[test]
fn test_dc_insert_breaks_1() { fn test_dc_insert_breaks_1() {
unsafe { unsafe {
let str: *mut libc::c_char = dc_insert_breaks( let str = dc_insert_breaks(
b"just1234test\x00" as *const u8 as *const libc::c_char, b"just1234test\x00" as *const u8 as *const libc::c_char,
4, 4,
b" \x00" as *const u8 as *const libc::c_char, b" \x00" as *const u8 as *const libc::c_char,

37
src/error.rs Normal file
View File

@@ -0,0 +1,37 @@
use failure::Fail;
#[derive(Debug, Fail)]
pub enum Error {
#[fail(display = "Sqlite Error: {:?}", _0)]
Sql(rusqlite::Error),
#[fail(display = "Sqlite Connection Pool Error: {:?}", _0)]
ConnectionPool(r2d2::Error),
#[fail(display = "{:?}", _0)]
Failure(failure::Error),
#[fail(display = "Sqlite: Connection closed")]
SqlNoConnection,
#[fail(display = "Sqlite: Already open")]
SqlAlreadyOpen,
#[fail(display = "Sqlite: Failed to open")]
SqlFailedToOpen,
}
pub type Result<T> = std::result::Result<T, Error>;
impl From<rusqlite::Error> for Error {
fn from(err: rusqlite::Error) -> Error {
Error::Sql(err)
}
}
impl From<failure::Error> for Error {
fn from(err: failure::Error) -> Error {
Error::Failure(err)
}
}
impl From<r2d2::Error> for Error {
fn from(err: r2d2::Error) -> Error {
Error::ConnectionPool(err)
}
}

64
src/imap.rs
View File

@@ -6,9 +6,9 @@ use std::time::{Duration, SystemTime};
use crate::constants::*; use crate::constants::*;
use crate::context::Context; use crate::context::Context;
use crate::dc_loginparam::*; use crate::dc_loginparam::*;
use crate::dc_sqlite3::*; use crate::dc_tools::as_str;
use crate::dc_tools::{as_str, to_string};
use crate::oauth2::dc_get_oauth2_access_token; use crate::oauth2::dc_get_oauth2_access_token;
use crate::sql;
use crate::types::*; use crate::types::*;
pub const DC_IMAP_SEEN: usize = 0x0001; pub const DC_IMAP_SEEN: usize = 0x0001;
@@ -522,12 +522,8 @@ impl Imap {
cfg.watch_folder = None; cfg.watch_folder = None;
} }
pub fn connect(&self, context: &Context, lp: *const dc_loginparam_t) -> bool { pub fn connect(&self, context: &Context, lp: &dc_loginparam_t) -> bool {
if lp.is_null() { if lp.mail_server.is_empty() || lp.mail_user.is_empty() || lp.mail_pw.is_empty() {
return false;
}
let lp = unsafe { *lp };
if lp.mail_server.is_null() || lp.mail_user.is_null() || lp.mail_pw.is_null() {
return false; return false;
} }
@@ -536,19 +532,19 @@ impl Imap {
} }
{ {
let addr = as_str(lp.addr); let addr = &lp.addr;
let imap_server = as_str(lp.mail_server); let imap_server = &lp.mail_server;
let imap_port = lp.mail_port as u16; let imap_port = lp.mail_port as u16;
let imap_user = as_str(lp.mail_user); let imap_user = &lp.mail_user;
let imap_pw = as_str(lp.mail_pw); let imap_pw = &lp.mail_pw;
let server_flags = lp.server_flags as usize; let server_flags = lp.server_flags as usize;
let mut config = self.config.write().unwrap(); let mut config = self.config.write().unwrap();
config.addr = addr.into(); config.addr = addr.to_string();
config.imap_server = imap_server.into(); config.imap_server = imap_server.to_string();
config.imap_port = imap_port.into(); config.imap_port = imap_port.into();
config.imap_user = imap_user.into(); config.imap_user = imap_user.to_string();
config.imap_pw = imap_pw.into(); config.imap_pw = imap_pw.to_string();
config.server_flags = server_flags; config.server_flags = server_flags;
} }
@@ -567,7 +563,7 @@ impl Imap {
context, context,
0, 0,
"IMAP-LOGIN as {} ok but ABORTING", "IMAP-LOGIN as {} ok but ABORTING",
as_str(lp.mail_user), lp.mail_user,
); );
teardown = true; teardown = true;
} else { } else {
@@ -579,13 +575,12 @@ impl Imap {
s += c; s += c;
s s
}); });
log_event!( log_event!(
context, context,
Event::IMAP_CONNECTED, Event::IMAP_CONNECTED,
0, 0,
"IMAP-LOGIN as {}, capabilities: {}", "IMAP-LOGIN as {}, capabilities: {}",
as_str(lp.mail_user), lp.mail_user,
caps_list, caps_list,
); );
@@ -619,8 +614,8 @@ impl Imap {
} }
} }
pub fn set_watch_folder(&self, watch_folder: *const libc::c_char) { pub fn set_watch_folder(&self, watch_folder: String) {
self.config.write().unwrap().watch_folder = Some(to_string(watch_folder)); self.config.write().unwrap().watch_folder = Some(watch_folder);
} }
pub fn fetch(&self, context: &Context) -> libc::c_int { pub fn fetch(&self, context: &Context) -> libc::c_int {
@@ -866,9 +861,8 @@ impl Imap {
.expect("missing message id"); .expect("missing message id");
let message_id_c = CString::new(message_id).unwrap(); let message_id_c = CString::new(message_id).unwrap();
let folder_c = CString::new(folder.as_ref().to_owned()).unwrap();
if 0 == unsafe { if 0 == unsafe {
(self.precheck_imf)(context, message_id_c.as_ptr(), folder_c.as_ptr(), cur_uid) (self.precheck_imf)(context, message_id_c.as_ptr(), folder.as_ref(), cur_uid)
} { } {
// check passed, go fetch the rest // check passed, go fetch the rest
if self.fetch_single_msg(context, &folder, cur_uid) == 0 { if self.fetch_single_msg(context, &folder, cur_uid) == 0 {
@@ -1021,12 +1015,11 @@ impl Imap {
if !is_deleted && msg.body().is_some() { if !is_deleted && msg.body().is_some() {
unsafe { unsafe {
let folder_c = CString::new(folder.as_ref().to_owned()).unwrap();
(self.receive_imf)( (self.receive_imf)(
context, context,
msg.body().unwrap().as_ptr() as *const libc::c_char, msg.body().unwrap().as_ptr() as *const libc::c_char,
msg.body().unwrap().len(), msg.body().unwrap().len(),
folder_c.as_ptr(), folder.as_ref(),
server_uid, server_uid,
flags as u32, flags as u32,
); );
@@ -1633,31 +1626,24 @@ impl Imap {
} }
} }
unsafe { sql::set_config_int(context, &context.sql, "folders_configured", 3);
dc_sqlite3_set_config_int(
context,
&context.sql,
b"folders_configured\x00" as *const u8 as *const libc::c_char,
3,
);
if let Some(ref mvbox_folder) = mvbox_folder { if let Some(ref mvbox_folder) = mvbox_folder {
dc_sqlite3_set_config( sql::set_config(
context, context,
&context.sql, &context.sql,
b"configured_mvbox_folder\x00" as *const u8 as *const libc::c_char, "configured_mvbox_folder",
CString::new(mvbox_folder.clone()).unwrap().as_ptr(), Some(mvbox_folder),
); );
} }
if let Some(ref sentbox_folder) = sentbox_folder { if let Some(ref sentbox_folder) = sentbox_folder {
dc_sqlite3_set_config( sql::set_config(
context, context,
&context.sql, &context.sql,
b"configured_sentbox_folder\x00" as *const u8 as *const libc::c_char, "configured_sentbox_folder",
CString::new(sentbox_folder.name()).unwrap().as_ptr(), Some(sentbox_folder.name()),
); );
} }
} }
}
fn list_folders( fn list_folders(
&self, &self,

130
src/key.rs
View File

@@ -10,9 +10,8 @@ use pgp::types::{KeyTrait, SecretKeyTrait};
use crate::constants::*; use crate::constants::*;
use crate::context::Context; use crate::context::Context;
use crate::dc_sqlite3::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::types::*; use crate::sql::{self, Sql};
use crate::x::*; use crate::x::*;
#[derive(Debug, PartialEq, Eq, Clone)] #[derive(Debug, PartialEq, Eq, Clone)]
@@ -113,19 +112,6 @@ impl Key {
Self::from_slice(bytes, key_type) Self::from_slice(bytes, key_type)
} }
pub fn from_stmt(
stmt: *mut sqlite3_stmt,
index: libc::c_int,
key_type: KeyType,
) -> Option<Self> {
assert!(!stmt.is_null(), "missing statement");
let data = unsafe { sqlite3_column_blob(stmt, index) as *const u8 };
let len = unsafe { sqlite3_column_bytes(stmt, index) };
Self::from_binary(data, len, key_type)
}
pub fn from_armored_string( pub fn from_armored_string(
data: &str, data: &str,
key_type: KeyType, key_type: KeyType,
@@ -158,61 +144,34 @@ impl Key {
pub fn from_self_public( pub fn from_self_public(
context: &Context, context: &Context,
self_addr: *const libc::c_char, self_addr: impl AsRef<str>,
sql: &SQLite, sql: &Sql,
) -> Option<Self> { ) -> Option<Self> {
if self_addr.is_null() { let addr = self_addr.as_ref();
return None;
}
let stmt = unsafe { sql::query_row(
dc_sqlite3_prepare(
context, context,
sql, sql,
b"SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8 "SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;",
as *const libc::c_char, &[addr],
0,
) )
}; .and_then(|blob: Vec<u8>| Self::from_slice(&blob, KeyType::Public))
unsafe { sqlite3_bind_text(stmt, 1, self_addr, -1, None) };
let key = if unsafe { sqlite3_step(stmt) } == 100 {
Self::from_stmt(stmt, 0, KeyType::Public)
} else {
None
};
unsafe { sqlite3_finalize(stmt) };
key
} }
pub fn from_self_private( pub fn from_self_private(
context: &Context, context: &Context,
self_addr: *const libc::c_char, self_addr: impl AsRef<str>,
sql: &SQLite, sql: &Sql,
) -> Option<Self> { ) -> Option<Self> {
if self_addr.is_null() { sql::query_row(
return None;
}
let stmt = unsafe {
dc_sqlite3_prepare(
context, context,
sql, sql,
b"SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;\x00" as *const u8 "SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;",
as *const libc::c_char, &[self_addr.as_ref()],
0,
) )
}; .and_then(|blob: Vec<u8>| Self::from_slice(&blob, KeyType::Private))
unsafe { sqlite3_bind_text(stmt, 1, self_addr, -1, None) };
let key = if unsafe { sqlite3_step(stmt) } == 100 {
Self::from_stmt(stmt, 0, KeyType::Private)
} else {
None
};
unsafe { sqlite3_finalize(stmt) };
key
} }
pub fn to_bytes(&self) -> Vec<u8> { pub fn to_bytes(&self) -> Vec<u8> {
@@ -340,57 +299,16 @@ pub fn dc_key_save_self_keypair(
context: &Context, context: &Context,
public_key: &Key, public_key: &Key,
private_key: &Key, private_key: &Key,
addr: *const libc::c_char, addr: impl AsRef<str>,
is_default: libc::c_int, is_default: libc::c_int,
sql: &SQLite, sql: &Sql,
) -> bool { ) -> bool {
if addr.is_null() { sql::execute(
return false;
}
let stmt = unsafe {
dc_sqlite3_prepare(
context, context,
sql, sql,
b"INSERT INTO keypairs (addr, is_default, public_key, private_key, created) VALUES (?,?,?,?,?);\x00" "INSERT INTO keypairs (addr, is_default, public_key, private_key, created) VALUES (?,?,?,?,?);",
as *const u8 as *const libc::c_char params![addr.as_ref(), is_default, public_key.to_bytes(), private_key.to_bytes(), time()],
) )
};
unsafe {
sqlite3_bind_text(stmt, 1, addr, -1, None);
sqlite3_bind_int(stmt, 2, is_default)
};
let pub_bytes = public_key.to_bytes();
let sec_bytes = private_key.to_bytes();
unsafe {
sqlite3_bind_blob(
stmt,
3,
pub_bytes.as_ptr() as *const _,
pub_bytes.len() as libc::c_int,
None,
)
};
unsafe {
sqlite3_bind_blob(
stmt,
4,
sec_bytes.as_ptr() as *const _,
sec_bytes.len() as libc::c_int,
None,
)
};
unsafe { sqlite3_bind_int64(stmt, 5, time() as sqlite3_int64) };
let success = if unsafe { sqlite3_step(stmt) } == 101 {
true
} else {
false
};
unsafe { sqlite3_finalize(stmt) };
success
} }
/// Make a fingerprint human-readable, in hex format. /// Make a fingerprint human-readable, in hex format.
@@ -526,8 +444,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
#[test] #[test]
#[ignore] // is too expensive #[ignore] // is too expensive
fn test_from_slice_roundtrip() { fn test_from_slice_roundtrip() {
let (public_key, private_key) = let (public_key, private_key) = crate::pgp::dc_pgp_create_keypair("hello").unwrap();
crate::pgp::dc_pgp_create_keypair(CString::new("hello").unwrap().as_ptr()).unwrap();
let binary = public_key.to_bytes(); let binary = public_key.to_bytes();
let public_key2 = Key::from_slice(&binary, KeyType::Public).expect("invalid public key"); let public_key2 = Key::from_slice(&binary, KeyType::Public).expect("invalid public key");
@@ -541,8 +458,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
#[test] #[test]
#[ignore] // is too expensive #[ignore] // is too expensive
fn test_ascii_roundtrip() { fn test_ascii_roundtrip() {
let (public_key, private_key) = let (public_key, private_key) = crate::pgp::dc_pgp_create_keypair("hello").unwrap();
crate::pgp::dc_pgp_create_keypair(CString::new("hello").unwrap().as_ptr()).unwrap();
let s = public_key.to_armored_string(None).unwrap(); let s = public_key.to_armored_string(None).unwrap();
let (public_key2, _) = let (public_key2, _) =

32
src/keyring.rs
View File

@@ -2,9 +2,8 @@ use std::borrow::Cow;
use crate::constants::*; use crate::constants::*;
use crate::context::Context; use crate::context::Context;
use crate::dc_sqlite3::*;
use crate::key::*; use crate::key::*;
use crate::types::*; use crate::sql::{self, Sql};
#[derive(Default, Clone, Debug)] #[derive(Default, Clone, Debug)]
pub struct Keyring<'a> { pub struct Keyring<'a> {
@@ -31,29 +30,18 @@ impl<'a> Keyring<'a> {
pub fn load_self_private_for_decrypting( pub fn load_self_private_for_decrypting(
&mut self, &mut self,
context: &Context, context: &Context,
self_addr: *const libc::c_char, self_addr: impl AsRef<str>,
sql: &SQLite, sql: &Sql,
) -> bool { ) -> bool {
// Can we prevent keyring and self_addr to be null? sql::query_row(
if self_addr.is_null() {
return false;
}
let stmt = unsafe {
dc_sqlite3_prepare(
context, context,
sql, sql,
b"SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;\x00" "SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;",
as *const u8 as *const libc::c_char, &[self_addr.as_ref()],
0,
) )
}; .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Private))
unsafe { sqlite3_bind_text(stmt, 1, self_addr, -1, None) }; .map(|key| self.add_owned(key))
while unsafe { sqlite3_step(stmt) == 100 } { .is_some()
if let Some(key) = Key::from_stmt(stmt, 0, KeyType::Private) {
self.add_owned(key);
}
}
unsafe { sqlite3_finalize(stmt) };
true
} }
} }

7
src/lib.rs
View File

@@ -14,13 +14,16 @@ extern crate failure_derive;
extern crate num_derive; extern crate num_derive;
#[macro_use] #[macro_use]
extern crate smallvec; extern crate smallvec;
#[macro_use]
extern crate rusqlite;
#[macro_use] #[macro_use]
pub mod dc_log; mod log;
pub mod aheader; pub mod aheader;
pub mod constants; pub mod constants;
pub mod context; pub mod context;
pub mod error;
pub mod imap; pub mod imap;
pub mod key; pub mod key;
pub mod keyhistory; pub mod keyhistory;
@@ -29,6 +32,7 @@ pub mod oauth2;
pub mod peerstate; pub mod peerstate;
pub mod pgp; pub mod pgp;
pub mod smtp; pub mod smtp;
pub mod sql;
pub mod types; pub mod types;
pub mod x; pub mod x;
@@ -55,7 +59,6 @@ pub mod dc_receive_imf;
pub mod dc_saxparser; pub mod dc_saxparser;
pub mod dc_securejoin; pub mod dc_securejoin;
pub mod dc_simplify; pub mod dc_simplify;
pub mod dc_sqlite3;
pub mod dc_stock; pub mod dc_stock;
pub mod dc_strencode; pub mod dc_strencode;
pub mod dc_token; pub mod dc_token;

51
src/log.rs Normal file
View File

@@ -0,0 +1,51 @@
#[macro_export]
macro_rules! info {
($ctx:expr, $data1:expr, $msg:expr) => {
info!($ctx, $data1, $msg,)
};
($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {{
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($crate::constants::Event::INFO, $data1 as libc::uintptr_t,
formatted_c.as_ptr() as libc::uintptr_t)
}};
}
#[macro_export]
macro_rules! warn {
($ctx:expr, $data1:expr, $msg:expr) => {
warn!($ctx, $data1, $msg,)
};
($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($crate::constants::Event::WARNING, $data1 as libc::uintptr_t,
formatted_c.as_ptr() as libc::uintptr_t)
};
}
#[macro_export]
macro_rules! error {
($ctx:expr, $data1:expr, $msg:expr) => {
error!($ctx, $data1, $msg,)
};
($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($crate::constants::Event::ERROR, $data1 as libc::uintptr_t,
formatted_c.as_ptr() as libc::uintptr_t)
};
}
#[macro_export]
macro_rules! log_event {
($ctx:expr, $data1:expr, $msg:expr) => {
log_event!($ctx, $data1, $msg,)
};
($ctx:expr, $event:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
let formatted = format!($msg, $($args),*);
let formatted_c = $crate::dc_tools::to_cstring(formatted);
$ctx.call_cb($event, $data1 as libc::uintptr_t,
formatted_c.as_ptr() as libc::uintptr_t)
};
}

76
src/oauth2.rs
View File

@@ -1,13 +1,11 @@
use std::collections::HashMap; use std::collections::HashMap;
use std::ffi::CString;
use percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET}; use percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET};
use serde::Deserialize; use serde::Deserialize;
use crate::context::Context; use crate::context::Context;
use crate::dc_sqlite3::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::types::*; use crate::sql;
const OAUTH2_GMAIL: Oauth2 = Oauth2 { const OAUTH2_GMAIL: Oauth2 = Oauth2 {
client_id: "959970109878-4mvtgf6feshskf7695nfln6002mom908.apps.googleusercontent.com", client_id: "959970109878-4mvtgf6feshskf7695nfln6002mom908.apps.googleusercontent.com",
@@ -51,10 +49,11 @@ pub fn dc_get_oauth2_url(
redirect_uri: impl AsRef<str>, redirect_uri: impl AsRef<str>,
) -> Option<String> { ) -> Option<String> {
if let Some(oauth2) = Oauth2::from_address(addr) { if let Some(oauth2) = Oauth2::from_address(addr) {
set_config( sql::set_config(
context, context,
&context.sql,
"oauth2_pending_redirect_uri", "oauth2_pending_redirect_uri",
redirect_uri.as_ref(), Some(redirect_uri.as_ref()),
); );
let oauth2_url = replace_in_uri(&oauth2.get_code, "$CLIENT_ID", &oauth2.client_id); let oauth2_url = replace_in_uri(&oauth2.get_code, "$CLIENT_ID", &oauth2.client_id);
let oauth2_url = replace_in_uri(&oauth2_url, "$REDIRECT_URI", redirect_uri.as_ref()); let oauth2_url = replace_in_uri(&oauth2_url, "$REDIRECT_URI", redirect_uri.as_ref());
@@ -79,16 +78,17 @@ pub fn dc_get_oauth2_access_token(
// read generated token // read generated token
if 0 == flags & 0x1 && !is_expired(context) { if 0 == flags & 0x1 && !is_expired(context) {
let access_token = get_config(context, "oauth2_access_token"); let access_token = sql::get_config(context, &context.sql, "oauth2_access_token", None);
if access_token.is_some() { if access_token.is_some() {
// success // success
return access_token; return access_token;
} }
} }
let refresh_token = get_config(context, "oauth2_refresh_token"); let refresh_token = sql::get_config(context, &context.sql, "oauth2_refresh_token", None);
let refresh_token_for = let refresh_token_for =
get_config(context, "oauth2_refresh_token_for").unwrap_or_else(|| "unset".into()); sql::get_config(context, &context.sql, "oauth2_refresh_token_for", None)
.unwrap_or_else(|| "unset".into());
let (redirect_uri, token_url, update_redirect_uri_on_success) = let (redirect_uri, token_url, update_redirect_uri_on_success) =
if refresh_token.is_none() || refresh_token_for != code.as_ref() { if refresh_token.is_none() || refresh_token_for != code.as_ref() {
@@ -97,7 +97,7 @@ pub fn dc_get_oauth2_access_token(
0, "Generate OAuth2 refresh_token and access_token...", 0, "Generate OAuth2 refresh_token and access_token...",
); );
( (
get_config(context, "oauth2_pending_redirect_uri") sql::get_config(context, &context.sql, "oauth2_pending_redirect_uri", None)
.unwrap_or_else(|| "unset".into()), .unwrap_or_else(|| "unset".into()),
oauth2.init_token, oauth2.init_token,
true, true,
@@ -108,7 +108,8 @@ pub fn dc_get_oauth2_access_token(
0, "Regenerate OAuth2 access_token by refresh_token...", 0, "Regenerate OAuth2 access_token by refresh_token...",
); );
( (
get_config(context, "oauth2_redirect_uri").unwrap_or_else(|| "unset".into()), sql::get_config(context, &context.sql, "oauth2_redirect_uri", None)
.unwrap_or_else(|| "unset".into()),
oauth2.refresh_token, oauth2.refresh_token,
false, false,
) )
@@ -151,23 +152,38 @@ pub fn dc_get_oauth2_access_token(
println!("response: {:?}", &parsed); println!("response: {:?}", &parsed);
let response = parsed.unwrap(); let response = parsed.unwrap();
if let Some(ref token) = response.refresh_token { if let Some(ref token) = response.refresh_token {
set_config(context, "oauth2_refresh_token", token); sql::set_config(context, &context.sql, "oauth2_refresh_token", Some(token));
set_config(context, "oauth2_refresh_token_for", code.as_ref()); sql::set_config(
context,
&context.sql,
"oauth2_refresh_token_for",
Some(code.as_ref()),
);
} }
// after that, save the access token. // after that, save the access token.
// if it's unset, we may get it in the next round as we have the refresh_token now. // if it's unset, we may get it in the next round as we have the refresh_token now.
if let Some(ref token) = response.access_token { if let Some(ref token) = response.access_token {
set_config(context, "oauth2_access_token", token); sql::set_config(context, &context.sql, "oauth2_access_token", Some(token));
let expires_in = response let expires_in = response
.expires_in .expires_in
// refresh a bet before // refresh a bet before
.map(|t| time() + t as i64 - 5) .map(|t| time() + t as i64 - 5)
.unwrap_or_else(|| 0); .unwrap_or_else(|| 0);
set_config_int64(context, "oauth2_timestamp_expires", expires_in); sql::set_config_int64(
context,
&context.sql,
"oauth2_timestamp_expires",
expires_in,
);
if update_redirect_uri_on_success { if update_redirect_uri_on_success {
set_config(context, "oauth2_redirect_uri", redirect_uri.as_ref()); sql::set_config(
context,
&context.sql,
"oauth2_redirect_uri",
Some(redirect_uri.as_ref()),
);
} }
} else { } else {
warn!(context, 0, "Failed to find OAuth2 access token"); warn!(context, 0, "Failed to find OAuth2 access token");
@@ -279,35 +295,9 @@ impl Oauth2 {
} }
} }
fn get_config(context: &Context, key: &str) -> Option<String> {
let key_c = CString::new(key).unwrap();
let res =
unsafe { dc_sqlite3_get_config(context, &context.sql, key_c.as_ptr(), std::ptr::null()) };
if res.is_null() {
return None;
}
Some(to_string(res))
}
fn set_config(context: &Context, key: &str, value: &str) {
let key_c = CString::new(key).unwrap();
let value_c = CString::new(value).unwrap();
unsafe { dc_sqlite3_set_config(context, &context.sql, key_c.as_ptr(), value_c.as_ptr()) };
}
fn set_config_int64(context: &Context, key: &str, value: i64) {
let key_c = CString::new(key).unwrap();
unsafe { dc_sqlite3_set_config_int64(context, &context.sql, key_c.as_ptr(), value) };
}
fn is_expired(context: &Context) -> bool { fn is_expired(context: &Context) -> bool {
let expire_timestamp = dc_sqlite3_get_config_int64( let expire_timestamp =
context, sql::get_config_int64(context, &context.sql, "oauth2_timestamp_expires", Some(0));
&context.sql,
b"oauth2_timestamp_expires\x00" as *const u8 as *const libc::c_char,
0i32 as int64_t,
);
if expire_timestamp <= 0 { if expire_timestamp <= 0 {
return false; return false;

319
src/peerstate.rs
View File

@@ -1,5 +1,4 @@
use std::collections::HashSet; use std::collections::HashSet;
use std::ffi::CString;
use std::fmt; use std::fmt;
use num_traits::FromPrimitive; use num_traits::FromPrimitive;
@@ -8,22 +7,20 @@ use crate::aheader::*;
use crate::constants::*; use crate::constants::*;
use crate::context::Context; use crate::context::Context;
use crate::dc_chat::*; use crate::dc_chat::*;
use crate::dc_sqlite3::*;
use crate::dc_tools::{to_cstring, to_string};
use crate::key::*; use crate::key::*;
use crate::types::*; use crate::sql::{self, Sql};
/// Peerstate represents the state of an Autocrypt peer. /// Peerstate represents the state of an Autocrypt peer.
pub struct Peerstate<'a> { pub struct Peerstate<'a> {
pub context: &'a Context, pub context: &'a Context,
pub addr: Option<String>, pub addr: Option<String>,
pub last_seen: u64, pub last_seen: i64,
pub last_seen_autocrypt: u64, pub last_seen_autocrypt: i64,
pub prefer_encrypt: EncryptPreference, pub prefer_encrypt: EncryptPreference,
pub public_key: Option<Key>, pub public_key: Option<Key>,
pub public_key_fingerprint: Option<String>, pub public_key_fingerprint: Option<String>,
pub gossip_key: Option<Key>, pub gossip_key: Option<Key>,
pub gossip_timestamp: u64, pub gossip_timestamp: i64,
pub gossip_key_fingerprint: Option<String>, pub gossip_key_fingerprint: Option<String>,
verified_key: VerifiedKey, verified_key: VerifiedKey,
pub verified_key_fingerprint: Option<String>, pub verified_key_fingerprint: Option<String>,
@@ -141,7 +138,7 @@ impl<'a> Peerstate<'a> {
} }
} }
pub fn from_header(context: &'a Context, header: &Aheader, message_time: u64) -> Self { pub fn from_header(context: &'a Context, header: &Aheader, message_time: i64) -> Self {
let mut res = Self::new(context); let mut res = Self::new(context);
res.addr = Some(header.addr.clone()); res.addr = Some(header.addr.clone());
@@ -155,7 +152,7 @@ impl<'a> Peerstate<'a> {
res res
} }
pub fn from_gossip(context: &'a Context, gossip_header: &Aheader, message_time: u64) -> Self { pub fn from_gossip(context: &'a Context, gossip_header: &Aheader, message_time: i64) -> Self {
let mut res = Self::new(context); let mut res = Self::new(context);
res.addr = Some(gossip_header.addr.clone()); res.addr = Some(gossip_header.addr.clone());
@@ -167,78 +164,59 @@ impl<'a> Peerstate<'a> {
res res
} }
pub fn from_addr(context: &'a Context, sql: &SQLite, addr: &str) -> Option<Self> { pub fn from_addr(context: &'a Context, _sql: &Sql, addr: &str) -> Option<Self> {
let mut res = None; let query = "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;";
let stmt = unsafe { Self::from_stmt(context, query, &[addr])
dc_sqlite3_prepare(
context,
sql,
b"SELECT addr, last_seen, last_seen_autocrypt, prefer_encrypted, public_key, gossip_timestamp, gossip_key, public_key_fingerprint, gossip_key_fingerprint, verified_key, verified_key_fingerprint FROM acpeerstates WHERE addr=? COLLATE NOCASE;\x00"
as *const u8 as *const libc::c_char)
};
let addr_c = CString::new(addr.as_bytes()).unwrap();
unsafe { sqlite3_bind_text(stmt, 1, addr_c.as_ptr(), -1, None) };
if unsafe { sqlite3_step(stmt) } == 100 {
res = Some(Self::from_stmt(context, stmt));
} }
unsafe { sqlite3_finalize(stmt) }; pub fn from_fingerprint(context: &'a Context, _sql: &Sql, fingerprint: &str) -> Option<Self> {
res let query = "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;";
let fp = fingerprint.as_bytes();
Self::from_stmt(context, query, params![fp, fp, fp])
} }
pub fn from_fingerprint(context: &'a Context, sql: &SQLite, fingerprint: &str) -> Option<Self> { fn from_stmt<P>(context: &'a Context, query: &str, params: P) -> Option<Self>
let mut res = None; where
P: IntoIterator,
let stmt = unsafe { P::Item: rusqlite::ToSql,
dc_sqlite3_prepare( {
context, context
sql, .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" .query_row(query, params, |row| {
as *const u8 as *const libc::c_char)
};
let fp_c = CString::new(fingerprint.as_bytes()).unwrap();
unsafe {
sqlite3_bind_text(stmt, 1, fp_c.as_ptr(), -1, None);
sqlite3_bind_text(stmt, 2, fp_c.as_ptr(), -1, None);
sqlite3_bind_text(stmt, 3, fp_c.as_ptr(), -1, None);
}
if unsafe { sqlite3_step(stmt) == 100 } {
res = Some(Self::from_stmt(context, stmt));
}
unsafe { sqlite3_finalize(stmt) };
res
}
fn from_stmt(context: &'a Context, stmt: *mut sqlite3_stmt) -> Self {
let mut res = Self::new(context); let mut res = Self::new(context);
res.addr = Some(to_string(unsafe { res.addr = Some(row.get(0)?);
sqlite3_column_text(stmt, 0) as *const _ res.last_seen = row.get(1)?;
})); res.last_seen_autocrypt = row.get(2)?;
res.last_seen = unsafe { sqlite3_column_int64(stmt, 1) } as u64; res.prefer_encrypt = EncryptPreference::from_i32(row.get(3)?).unwrap_or_default();
res.last_seen_autocrypt = unsafe { sqlite3_column_int64(stmt, 2) } as u64; res.gossip_timestamp = row.get(5)?;
res.prefer_encrypt = let pkf: String = row.get(7)?;
EncryptPreference::from_i32(unsafe { sqlite3_column_int(stmt, 3) }).unwrap_or_default();
res.gossip_timestamp = unsafe { sqlite3_column_int(stmt, 5) } as u64;
let pkf = to_string(unsafe { sqlite3_column_text(stmt, 7) as *const _ });
res.public_key_fingerprint = if pkf.is_empty() { None } else { Some(pkf) }; res.public_key_fingerprint = if pkf.is_empty() { None } else { Some(pkf) };
let gkf = to_string(unsafe { sqlite3_column_text(stmt, 8) as *const _ }); let gkf: String = row.get(8)?;
res.gossip_key_fingerprint = if gkf.is_empty() { None } else { Some(gkf) }; res.gossip_key_fingerprint = if gkf.is_empty() { None } else { Some(gkf) };
let vkf = to_string(unsafe { sqlite3_column_text(stmt, 10) as *const _ }); let vkf: String = row.get(10)?;
res.verified_key_fingerprint = if vkf.is_empty() { None } else { Some(vkf) }; res.verified_key_fingerprint = if vkf.is_empty() { None } else { Some(vkf) };
if unsafe { sqlite3_column_type(stmt, 4) } != 5 { res.public_key = row
res.public_key = Key::from_stmt(stmt, 4, KeyType::Public); .get(4)
} .ok()
if unsafe { sqlite3_column_type(stmt, 6) } != 5 { .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
res.gossip_key = Key::from_stmt(stmt, 6, KeyType::Public); res.gossip_key = row
} .get(6)
if unsafe { sqlite3_column_type(stmt, 9) } != 5 { .ok()
let vk = Key::from_stmt(stmt, 9, KeyType::Public); .and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
let vk = row
.get(9)
.ok()
.and_then(|blob: Vec<u8>| Key::from_slice(&blob, KeyType::Public));
res.verified_key = if vk == res.gossip_key { res.verified_key = if vk == res.gossip_key {
VerifiedKey::Gossip VerifiedKey::Gossip
} else if vk == res.public_key { } else if vk == res.public_key {
@@ -246,9 +224,10 @@ impl<'a> Peerstate<'a> {
} else { } else {
VerifiedKey::None VerifiedKey::None
}; };
}
res Ok(res)
})
.ok()
} }
pub fn recalc_fingerprint(&mut self) { pub fn recalc_fingerprint(&mut self) {
@@ -283,7 +262,7 @@ impl<'a> Peerstate<'a> {
} }
} }
pub fn degrade_encryption(&mut self, message_time: u64) { pub fn degrade_encryption(&mut self, message_time: i64) {
if self.prefer_encrypt == EncryptPreference::Mutual { if self.prefer_encrypt == EncryptPreference::Mutual {
self.degrade_event = Some(DegradeEvent::EncryptionPaused); self.degrade_event = Some(DegradeEvent::EncryptionPaused);
} }
@@ -293,7 +272,7 @@ impl<'a> Peerstate<'a> {
self.to_save = Some(ToSave::All); self.to_save = Some(ToSave::All);
} }
pub fn apply_header(&mut self, header: &Aheader, message_time: u64) { pub fn apply_header(&mut self, header: &Aheader, message_time: i64) {
if self.addr.is_none() if self.addr.is_none()
|| self.addr.as_ref().unwrap().to_lowercase() != header.addr.to_lowercase() || self.addr.as_ref().unwrap().to_lowercase() != header.addr.to_lowercase()
{ {
@@ -325,7 +304,7 @@ impl<'a> Peerstate<'a> {
} }
} }
pub fn apply_gossip(&mut self, gossip_header: &Aheader, message_time: u64) { pub fn apply_gossip(&mut self, gossip_header: &Aheader, message_time: i64) {
if self.addr.is_none() if self.addr.is_none()
|| self.addr.as_ref().unwrap().to_lowercase() != gossip_header.addr.to_lowercase() || self.addr.as_ref().unwrap().to_lowercase() != gossip_header.addr.to_lowercase()
{ {
@@ -400,7 +379,7 @@ impl<'a> Peerstate<'a> {
success success
} }
pub fn save_to_db(&self, sql: &SQLite, create: bool) -> bool { pub fn save_to_db(&self, sql: &Sql, create: bool) -> bool {
let mut success = false; let mut success = false;
if self.addr.is_none() { if self.addr.is_none() {
@@ -408,158 +387,56 @@ impl<'a> Peerstate<'a> {
} }
if create { if create {
let stmt = unsafe { if !sql::execute(
dc_sqlite3_prepare(
self.context, self.context,
sql, sql,
b"INSERT INTO acpeerstates (addr) VALUES(?);\x00" as *const u8 "INSERT INTO acpeerstates (addr) VALUES(?);",
as *const libc::c_char, params![self.addr.as_ref().unwrap()],
) ) {
}; return false;
let addr_c = to_cstring(self.addr.as_ref().unwrap());
unsafe {
sqlite3_bind_text(stmt, 1, addr_c.as_ptr(), -1, None);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
} }
} }
if self.to_save == Some(ToSave::All) || create { if self.to_save == Some(ToSave::All) || create {
let stmt = unsafe { success = sql::execute(
dc_sqlite3_prepare( self.context,
self.context, sql, sql,
b"UPDATE acpeerstates \ "UPDATE acpeerstates \
SET last_seen=?, last_seen_autocrypt=?, prefer_encrypted=?, \ 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=? \ public_key=?, gossip_timestamp=?, gossip_key=?, public_key_fingerprint=?, gossip_key_fingerprint=?, \
WHERE addr=?;\x00" verified_key=?, verified_key_fingerprint=? \
as *const u8 as *const libc::c_char WHERE addr=?;",
) params![
}; self.last_seen,
self.last_seen_autocrypt,
unsafe { sqlite3_bind_int64(stmt, 1, self.last_seen as sqlite3_int64) }; self.prefer_encrypt as i64,
unsafe { sqlite3_bind_int64(stmt, 2, self.last_seen_autocrypt as sqlite3_int64) }; self.public_key.as_ref().map(|k| k.to_bytes()),
unsafe { sqlite3_bind_int64(stmt, 3, self.prefer_encrypt as sqlite3_int64) }; self.gossip_timestamp,
self.gossip_key.as_ref().map(|k| k.to_bytes()),
let pub_bytes = self &self.public_key_fingerprint,
.public_key &self.gossip_key_fingerprint,
.as_ref() self.verified_key().map(|k| k.to_bytes()),
.map(|k| k.to_bytes()) &self.verified_key_fingerprint,
.unwrap_or_default(); &self.addr,
let gossip_bytes = self ],
.gossip_key );
.as_ref()
.map(|k| k.to_bytes())
.unwrap_or_default();
let ver_bytes = self
.verified_key()
.as_ref()
.map(|k| k.to_bytes())
.unwrap_or_default();
let pkc = self
.public_key_fingerprint
.as_ref()
.map(to_cstring)
.unwrap_or_default();
let pkc_ptr = if self.public_key_fingerprint.is_some() {
pkc.as_ptr()
} else {
std::ptr::null()
};
let gkc = self
.gossip_key_fingerprint
.as_ref()
.map(to_cstring)
.unwrap_or_default();
let gkc_ptr = if self.gossip_key_fingerprint.is_some() {
gkc.as_ptr()
} else {
std::ptr::null_mut()
};
let vkc = self
.verified_key_fingerprint
.as_ref()
.map(to_cstring)
.unwrap_or_default();
let vkc_ptr = if self.verified_key_fingerprint.is_some() {
vkc.as_ptr()
} else {
std::ptr::null_mut()
};
let addr: String = self.addr.clone().unwrap_or_default();
let addr_c = to_cstring(addr);
unsafe {
sqlite3_bind_blob(
stmt,
4,
pub_bytes.as_ptr() as *const _,
pub_bytes.len() as libc::c_int,
SQLITE_TRANSIENT(),
)
};
unsafe { sqlite3_bind_int64(stmt, 5, self.gossip_timestamp as sqlite3_int64) };
unsafe {
sqlite3_bind_blob(
stmt,
6,
gossip_bytes.as_ptr() as *const _,
gossip_bytes.len() as libc::c_int,
SQLITE_TRANSIENT(),
)
};
unsafe { sqlite3_bind_text(stmt, 7, pkc_ptr as *const _, -1, SQLITE_TRANSIENT()) };
unsafe { sqlite3_bind_text(stmt, 8, gkc_ptr as *const _, -1, SQLITE_TRANSIENT()) };
unsafe {
sqlite3_bind_blob(
stmt,
9,
ver_bytes.as_ptr() as *const _,
ver_bytes.len() as libc::c_int,
SQLITE_TRANSIENT(),
)
};
unsafe { sqlite3_bind_text(stmt, 10, vkc_ptr as *const _, -1, SQLITE_TRANSIENT()) };
unsafe { sqlite3_bind_text(stmt, 11, addr_c.as_ptr(), -1, SQLITE_TRANSIENT()) };
if unsafe { sqlite3_step(stmt) } == 101 {
success = true;
}
unsafe { sqlite3_finalize(stmt) };
} else if self.to_save == Some(ToSave::Timestamps) { } else if self.to_save == Some(ToSave::Timestamps) {
let stmt = unsafe { success = sql::execute(
dc_sqlite3_prepare( self.context,
&self.context,sql, sql,
b"UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? WHERE addr=?;\x00" "UPDATE acpeerstates SET last_seen=?, last_seen_autocrypt=?, gossip_timestamp=? \
as *const u8 as *const libc::c_char) WHERE addr=?;",
}; params![
self.last_seen,
let c_addr = self.addr.as_ref().map(to_cstring).unwrap_or_default(); self.last_seen_autocrypt,
let addr_ptr = if self.addr.is_some() { self.gossip_timestamp,
c_addr.as_ptr() &self.addr
} else { ],
std::ptr::null() );
};
unsafe { sqlite3_bind_int64(stmt, 1, self.last_seen as sqlite3_int64) };
unsafe { sqlite3_bind_int64(stmt, 2, self.last_seen_autocrypt as sqlite3_int64) };
unsafe { sqlite3_bind_int64(stmt, 3, self.gossip_timestamp as sqlite3_int64) };
unsafe { sqlite3_bind_text(stmt, 4, addr_ptr, -1, SQLITE_TRANSIENT()) };
if unsafe { sqlite3_step(stmt) } == 101 {
success = true;
}
unsafe { sqlite3_finalize(stmt) };
} }
if self.to_save == Some(ToSave::All) || create { if self.to_save == Some(ToSave::All) || create {
unsafe { dc_reset_gossiped_timestamp(self.context, 0 as uint32_t) }; dc_reset_gossiped_timestamp(self.context, 0);
} }
success success
@@ -582,7 +459,7 @@ mod tests {
use super::*; use super::*;
use pretty_assertions::assert_eq; use pretty_assertions::assert_eq;
use std::ffi::CStr; use std::ffi::{CStr, CString};
use tempfile::{tempdir, TempDir}; use tempfile::{tempdir, TempDir};
use crate::context::*; use crate::context::*;
@@ -631,9 +508,9 @@ mod tests {
unsafe extern "C" fn cb( unsafe extern "C" fn cb(
_context: &Context, _context: &Context,
_event: Event, _event: Event,
_data1: uintptr_t, _data1: libc::uintptr_t,
_data2: uintptr_t, _data2: libc::uintptr_t,
) -> uintptr_t { ) -> libc::uintptr_t {
0 0
} }

4
src/pgp.rs
View File

@@ -137,8 +137,8 @@ pub unsafe fn dc_split_armored_data(
} }
/// Create a new key pair. /// Create a new key pair.
pub fn dc_pgp_create_keypair(addr: *const libc::c_char) -> Option<(Key, Key)> { pub fn dc_pgp_create_keypair(addr: impl AsRef<str>) -> Option<(Key, Key)> {
let user_id = format!("<{}>", unsafe { CStr::from_ptr(addr).to_str().unwrap() }); let user_id = format!("<{}>", addr.as_ref());
let key_params = SecretKeyParamsBuilder::default() let key_params = SecretKeyParamsBuilder::default()
.key_type(PgpKeyType::Rsa(2048)) .key_type(PgpKeyType::Rsa(2048))

45
src/smtp.rs
View File

@@ -1,5 +1,3 @@
use std::ffi::CStr;
use lettre::smtp::client::net::*; use lettre::smtp::client::net::*;
use lettre::*; use lettre::*;
@@ -7,9 +5,7 @@ use crate::constants::Event;
use crate::constants::*; use crate::constants::*;
use crate::context::Context; use crate::context::Context;
use crate::dc_loginparam::*; use crate::dc_loginparam::*;
use crate::dc_tools::*;
use crate::oauth2::*; use crate::oauth2::*;
use crate::types::*;
pub struct Smtp { pub struct Smtp {
transport: Option<lettre::smtp::SmtpTransport>, transport: Option<lettre::smtp::SmtpTransport>,
@@ -47,30 +43,17 @@ impl Smtp {
} }
/// Connect using the provided login params /// Connect using the provided login params
pub fn connect(&mut self, context: &Context, lp: *const dc_loginparam_t) -> bool { pub fn connect(&mut self, context: &Context, lp: &dc_loginparam_t) -> bool {
if lp.is_null() {
return false;
}
if self.is_connected() { if self.is_connected() {
warn!(context, 0, "SMTP already connected."); warn!(context, 0, "SMTP already connected.");
return true; return true;
} }
// Safe because we checked for null pointer above. if lp.send_server.is_empty() || lp.send_port == 0 {
let lp = unsafe { *lp };
if lp.addr.is_null() || lp.send_server.is_null() || lp.send_port == 0 {
log_event!(context, Event::ERROR_NETWORK, 0, "SMTP bad parameters.",); log_event!(context, Event::ERROR_NETWORK, 0, "SMTP bad parameters.",);
} }
let raw_addr = unsafe { self.from = if let Ok(addr) = EmailAddress::new(lp.addr.clone()) {
CStr::from_ptr(lp.addr)
.to_str()
.expect("invalid from address")
.to_string()
};
self.from = if let Ok(addr) = EmailAddress::new(raw_addr) {
Some(addr) Some(addr)
} else { } else {
None None
@@ -81,11 +64,7 @@ impl Smtp {
return false; return false;
} }
let domain = unsafe { let domain = &lp.send_server;
CStr::from_ptr(lp.send_server)
.to_str()
.expect("invalid send server")
};
let port = lp.send_port as u16; let port = lp.send_port as u16;
let tls = native_tls::TlsConnector::builder() let tls = native_tls::TlsConnector::builder()
@@ -99,19 +78,19 @@ impl Smtp {
let creds = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) { let creds = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
// oauth2 // oauth2
let addr = as_str(lp.addr); let addr = &lp.addr;
let send_pw = as_str(lp.send_pw); let send_pw = &lp.send_pw;
let access_token = dc_get_oauth2_access_token(context, addr, send_pw, 0); let access_token = dc_get_oauth2_access_token(context, addr, send_pw, 0);
if access_token.is_none() { if access_token.is_none() {
return false; return false;
} }
let user = as_str(lp.send_user); let user = &lp.send_user;
lettre::smtp::authentication::Credentials::new(user.into(), access_token.unwrap()) lettre::smtp::authentication::Credentials::new(user.to_string(), access_token.unwrap())
} else { } else {
// plain // plain
let user = unsafe { CStr::from_ptr(lp.send_user).to_str().unwrap().to_string() }; let user = lp.send_user.clone();
let pw = unsafe { CStr::from_ptr(lp.send_pw).to_str().unwrap().to_string() }; let pw = lp.send_pw.clone();
lettre::smtp::authentication::Credentials::new(user, pw) lettre::smtp::authentication::Credentials::new(user, pw)
}; };
@@ -123,7 +102,7 @@ impl Smtp {
lettre::smtp::ClientSecurity::Wrapper(tls_parameters) lettre::smtp::ClientSecurity::Wrapper(tls_parameters)
}; };
match lettre::smtp::SmtpClient::new((domain, port), security) { match lettre::smtp::SmtpClient::new((domain.as_str(), port), security) {
Ok(client) => { Ok(client) => {
let client = client let client = client
.smtp_utf8(true) .smtp_utf8(true)
@@ -135,7 +114,7 @@ impl Smtp {
Event::SMTP_CONNECTED, Event::SMTP_CONNECTED,
0, 0,
"SMTP-LOGIN as {} ok", "SMTP-LOGIN as {} ok",
as_str(lp.send_user), lp.send_user,
); );
true true
} }

1165
src/sql.rs Normal file
View File

File diff suppressed because it is too large Load Diff

6
src/types.rs
View File

@@ -1,9 +1,9 @@
use crate::constants::Event; use crate::constants::Event;
use crate::context::Context; use crate::context::Context;
pub use libsqlite3_sys::*;
pub use mmime::carray::*; pub use mmime::carray::*;
pub use mmime::clist::*; pub use mmime::clist::*;
pub use rusqlite::ffi::*;
/// Callback function that should be given to dc_context_new(). /// Callback function that should be given to dc_context_new().
/// ///
@@ -22,7 +22,7 @@ pub type dc_receive_imf_t = unsafe fn(
_: &Context, _: &Context,
_: *const libc::c_char, _: *const libc::c_char,
_: size_t, _: size_t,
_: *const libc::c_char, _: &str,
_: uint32_t, _: uint32_t,
_: uint32_t, _: uint32_t,
) -> (); ) -> ();
@@ -32,7 +32,7 @@ Context is only used for logging and to get information about
the online state. */ the online state. */
pub type dc_precheck_imf_t = pub type dc_precheck_imf_t =
unsafe fn(_: &Context, _: *const libc::c_char, _: *const libc::c_char, _: u32) -> libc::c_int; unsafe fn(_: &Context, _: *const libc::c_char, _: &str, _: u32) -> libc::c_int;
pub type dc_set_config_t = pub type dc_set_config_t =
unsafe fn(_: &Context, _: *const libc::c_char, _: *const libc::c_char) -> (); unsafe fn(_: &Context, _: *const libc::c_char, _: *const libc::c_char) -> ();
pub type dc_get_config_t = pub type dc_get_config_t =

6
src/x.rs
View File

@@ -45,12 +45,6 @@ extern "C" {
unsafe extern "C" fn(_: *const libc::c_void, _: *const libc::c_void) -> libc::c_int, unsafe extern "C" fn(_: *const libc::c_void, _: *const libc::c_void) -> libc::c_int,
>, >,
); );
pub fn vsnprintf(
_: *mut libc::c_char,
_: libc::c_ulong,
_: *const libc::c_char,
_: ::std::ffi::VaList,
) -> libc::c_int;
// -- DC Methods // -- DC Methods
pub fn dc_mprintf(format: *const libc::c_char, _: ...) -> *mut libc::c_char; pub fn dc_mprintf(format: *const libc::c_char, _: ...) -> *mut libc::c_char;

67
tests/stress.rs
View File

@@ -9,7 +9,9 @@ use tempfile::{tempdir, TempDir};
use deltachat::constants::*; use deltachat::constants::*;
use deltachat::context::*; use deltachat::context::*;
use deltachat::dc_array::*; use deltachat::dc_array::*;
use deltachat::dc_chat::*;
use deltachat::dc_configure::*; use deltachat::dc_configure::*;
use deltachat::dc_contact::*;
use deltachat::dc_imex::*; use deltachat::dc_imex::*;
use deltachat::dc_location::*; use deltachat::dc_location::*;
use deltachat::dc_lot::*; use deltachat::dc_lot::*;
@@ -244,15 +246,8 @@ unsafe fn stress_functions(context: &Context) {
free(fn0 as *mut libc::c_void); free(fn0 as *mut libc::c_void);
free(fn1 as *mut libc::c_void); free(fn1 as *mut libc::c_void);
} }
let keys = dc_get_config(
context,
b"sys.config_keys\x00" as *const u8 as *const libc::c_char,
);
assert!(!keys.is_null());
assert_ne!(0, *keys.offset(0isize) as libc::c_int);
let res = format!(" {} ", as_str(keys)); let res = dc_get_config(context, "sys.config_keys");
free(keys as *mut libc::c_void);
assert!(!res.contains(" probably_never_a_key ")); assert!(!res.contains(" probably_never_a_key "));
assert!(res.contains(" addr ")); assert!(res.contains(" addr "));
@@ -669,13 +664,11 @@ fn test_encryption_decryption() {
j += 1 j += 1
} }
let (public_key, private_key) = let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap();
dc_pgp_create_keypair(b"foo@bar.de\x00" as *const u8 as *const libc::c_char).unwrap();
private_key.split_key().unwrap(); private_key.split_key().unwrap();
let (public_key2, private_key2) = let (public_key2, private_key2) = dc_pgp_create_keypair("two@zwo.de").unwrap();
dc_pgp_create_keypair(b"two@zwo.de\x00" as *const u8 as *const libc::c_char).unwrap();
assert_ne!(public_key, public_key2); assert_ne!(public_key, public_key2);
@@ -954,6 +947,56 @@ fn test_stress_tests() {
} }
} }
#[test]
fn test_get_contacts() {
unsafe {
let context = create_test_context();
let contacts = dc_get_contacts(&context.ctx, 0, to_cstring("some2").as_ptr());
assert_eq!(dc_array_get_cnt(contacts), 0);
dc_array_unref(contacts);
let id = dc_create_contact(
&context.ctx,
to_cstring("bob").as_ptr(),
to_cstring("bob@mail.de").as_ptr(),
);
assert_ne!(id, 0);
let contacts = dc_get_contacts(&context.ctx, 0, to_cstring("bob").as_ptr());
assert_eq!(dc_array_get_cnt(contacts), 1);
dc_array_unref(contacts);
let contacts = dc_get_contacts(&context.ctx, 0, to_cstring("alice").as_ptr());
assert_eq!(dc_array_get_cnt(contacts), 0);
dc_array_unref(contacts);
}
}
#[test]
fn test_chat() {
unsafe {
let context = create_test_context();
let contact1 = dc_create_contact(
&context.ctx,
to_cstring("bob").as_ptr(),
to_cstring("bob@mail.de").as_ptr(),
);
assert_ne!(contact1, 0);
let chat_id = dc_create_chat_by_contact_id(&context.ctx, contact1);
assert!(chat_id > 9, "chat_id too small {}", chat_id);
let chat = dc_chat_new(&context.ctx);
assert!(dc_chat_load_from_db(chat, chat_id));
let chat2_id = dc_create_chat_by_contact_id(&context.ctx, contact1);
assert_eq!(chat2_id, chat_id);
let chat2 = dc_chat_new(&context.ctx);
assert!(dc_chat_load_from_db(chat2, chat2_id));
assert_eq!(as_str((*chat2).name), as_str((*chat).name));
}
}
#[test] #[test]
fn test_arr_to_string() { fn test_arr_to_string() {
let arr2: [uint32_t; 4] = [ let arr2: [uint32_t; 4] = [